Automatische HTTPS-Verbindung / Umleitung mit node.js / express

Ich habe versucht, HTTPS mit einem node.js-Projekt einzurichten, an dem ich arbeite. Ich habe im Wesentlichen die Dokumentation zu node.js für dieses Beispiel befolgt :

// curl -k https://localhost:8000/
var https = require('https');
var fs = require('fs');

var options = {
  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
};

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

Nun, wenn ich es tue

curl -k https://localhost:8000/

Ich bekomme

hello world

wie erwartet. Aber wenn ich es mache

curl -k http://localhost:8000/

Ich bekomme

curl: (52) Empty reply from server

Rückblickend scheint dies offensichtlich, dass es auf diese Weise funktionieren würde, aber gleichzeitig werden Leute, die mein Projekt schließlich besuchen, nicht https : // yadayada eingeben, und ich möchte, dass der gesamte Datenverkehr von dem Moment an https ist, in dem sie eintreffen der Standort.

Wie kann ich den Knoten (und Express, da dies das Framework ist, das ich verwende) dazu bringen, den gesamten eingehenden Datenverkehr an https weiterzuleiten, unabhängig davon, ob er angegeben wurde oder nicht? Ich konnte keine Dokumentation finden, die sich damit befasst. Oder wird nur angenommen, dass in einer Produktionsumgebung ein Knoten etwas vor sich hat (z. B. Nginx), das diese Art der Umleitung handhabt?

Dies ist mein erster Ausflug in die Webentwicklung. Bitte verzeihen Sie meine Unwissenheit, wenn dies offensichtlich ist.

Ryan, danke, dass du mich in die richtige Richtung gelenkt hast. Ich habe Ihre Antwort (2. Absatz) ein wenig mit etwas Code ausgearbeitet und es funktioniert. In diesem Szenario werden diese Codefragmente in meine Express-App eingefügt:

// set up plain http server
var http = express.createServer();

// set up a route to redirect http to https
http.get('*', function(req, res) {  
    res.redirect('https://' + req.headers.host + req.url);

    // Or, if you don't want to automatically detect the domain name from the request header, you can hard code it:
    // res.redirect('https://example.com' + req.url);
})

// have it listen on 8080
http.listen(8080);

Der https-Express-Server überwacht den Geldautomaten auf 3000. Ich habe diese iptables-Regeln eingerichtet, damit der Knoten nicht als root ausgeführt werden muss:

iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 3000

Alles in allem funktioniert das genau so, wie ich es wollte.

Wenn Sie herkömmlichen Ports folgen, da HTTP standardmäßig Port 80 und HTTPS standardmäßig Port 443 versucht, können Sie einfach zwei Server auf demselben Computer haben: Hier ist der Code:

var https = require('https');

var fs = require('fs');
var options = {
    key: fs.readFileSync('./key.pem'),
    cert: fs.readFileSync('./cert.pem')
};

https.createServer(options, function (req, res) {
    res.end('secure!');
}).listen(443);

// Redirect from http port 80 to https
var http = require('http');
http.createServer(function (req, res) {
    res.writeHead(301, { "Location": "https://" + req.headers['host'] + req.url });
    res.end();
}).listen(80);

Test mit https:

$ curl https://127.0.0.1 -k
secure!

Mit http:

$ curl http://127.0.0.1 -i
HTTP/1.1 301 Moved Permanently
Location: https://127.0.0.1/
Date: Sun, 01 Jun 2014 06:15:16 GMT
Connection: keep-alive
Transfer-Encoding: chunked

Weitere Details: Nodejs HTTP und HTTPS über denselben Port

Vielen Dank an diesen Typen: https://www.tonyerwin.com/2014/09/redirecting-http-to-https-with-nodejs.html

app.use (function (req, res, next) {
        if (req.secure) {
                // request was via https, so do no special handling
                next();
        } else {
                // request was via http, so redirect to https
                res.redirect('https://' + req.headers.host + req.url);
        }
});

Mit Nginx können Sie den "x-forwarded-proto" -Header nutzen:

function ensureSec(req, res, next){
    if (req.headers["x-forwarded-proto"] === "https"){
       return next();
    }
    res.redirect("https://" + req.headers.host + req.url);  
}

Ab 0.4.12 gibt es keine wirklich saubere Möglichkeit, HTTP und HTTPS am selben Port mithilfe der HTTP / HTTPS-Server von Node abzuhören.

Einige Benutzer haben dieses Problem gelöst, indem der HTTPS-Server von Node (dies funktioniert auch mit Express.js) 443 (oder einen anderen Port) abhört und einen kleinen http-Server an 80 bindet und Benutzer an den sicheren Port umleitet.

Wenn Sie unbedingt in der Lage sein müssen, beide Protokolle an einem einzigen Port zu verarbeiten, müssen Sie nginx, lighttpd, apache oder einen anderen Webserver an diesen Port anschließen und als Reverse-Proxy für Node fungieren.

Sie können das Express-Force-https- Modul verwenden:

npm install --save express-force-https

var express = require('express');
var secure = require('express-force-https');

var app = express();
app.use(secure);

Ich verwende die von Basarat vorgeschlagene Lösung, muss aber auch den Port überschreiben, da ich früher zwei verschiedene Ports für HTTP- und HTTPS-Protokolle hatte.

res.writeHead(301, { "Location": "https://" + req.headers['host'].replace(http_port,https_port) + req.url });

Ich bevorzuge es auch, keinen Standardport zu verwenden, um NodeJS ohne Root-Rechte zu starten. Ich mag 8080 und 8443, weil ich aus vielen Jahren der Programmierung auf Tomcat stamme.

Meine komplette Datei wird

var fs = require('fs');
var http = require('http');
var http_port    =   process.env.PORT || 8080; 
var app = require('express')();

// HTTPS definitions
var https = require('https');
var https_port    =   process.env.PORT_HTTPS || 8443; 
var options = {
   key  : fs.readFileSync('server.key'),
   cert : fs.readFileSync('server.crt')
};

app.get('/', function (req, res) {
   res.send('Hello World!');
});

https.createServer(options, app).listen(https_port, function () {
   console.log('Magic happens on port ' + https_port); 
});

// Redirect from http port to https
http.createServer(function (req, res) {
    res.writeHead(301, { "Location": "https://" + req.headers['host'].replace(http_port,https_port) + req.url });
    console.log("http request, will go to >> ");
    console.log("https://" + req.headers['host'].replace(http_port,https_port) + req.url );
    res.end();
}).listen(http_port);

Dann verwende ich iptable, um 80- und 443-Verkehr auf meinen HTTP- und HTTPS-Ports zu formulieren.

sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8080
sudo iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 8443

Diese Antwort muss aktualisiert werden, damit sie mit Express 4.0 funktioniert. So habe ich den separaten http-Server zum Laufen gebracht:

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

// Primary https app
var app = express()
var port = process.env.PORT || 3000;
app.set('env', 'development');
app.set('port', port);
var router = express.Router();
app.use('/', router);
// ... other routes here
var certOpts = {
    key: '/path/to/key.pem',
    cert: '/path/to/cert.pem'
};
var server = https.createServer(certOpts, app);
server.listen(port, function(){
    console.log('Express server listening to port '+port);
});


// Secondary http app
var httpApp = express();
var httpRouter = express.Router();
httpApp.use('*', httpRouter);
httpRouter.get('*', function(req, res){
    var host = req.get('Host');
    // replace the port in the host
    host = host.replace(/:\d+$/, ":"+app.get('port'));
    // determine the redirect destination
    var destination = ['https://', host, req.url].join('');
    return res.redirect(destination);
});
var httpServer = http.createServer(httpApp);
httpServer.listen(8080);

Wenn sich Ihre App hinter einem vertrauenswürdigen Proxy befindet (z. B. einem AWS ELB oder einem korrekt konfigurierten Nginx), sollte dieser Code funktionieren:

app.enable('trust proxy');
app.use(function(req, res, next) {
    if (req.secure){
        return next();
    }
    res.redirect("https://" + req.headers.host + req.url);
});

Anmerkungen:

• Dies setzt voraus, dass Sie Ihre Site auf 80 und 443 hosten. Andernfalls müssen Sie den Port bei der Umleitung ändern
• Dies setzt auch voraus, dass Sie das SSL auf dem Proxy beenden. Wenn Sie SSL von Ende zu Ende ausführen, verwenden Sie die Antwort von @basarat oben. End-to-End-SSL ist die bessere Lösung.
• Mit app.enable ('Trust Proxy') kann Express den X-Forwarded-Proto-Header überprüfen

Ich finde, dass req.protocol funktioniert, wenn ich Express verwende (habe nicht ohne getestet, aber ich vermute, dass es funktioniert). unter Verwendung des aktuellen Knotens 0.10.22 mit Express 3.4.3

app.use(function(req,res,next) {
  if (!/https/.test(req.protocol)){
     res.redirect("https://" + req.headers.host + req.url);
  } else {
     return next();
  } 
});

Die meisten Antworten hier schlagen vor, den Header req.headers.host zu verwenden.

Der Host-Header wird von HTTP 1.1 benötigt, ist jedoch optional, da der Header möglicherweise nicht von einem HTTP-Client gesendet wird und Node / Express diese Anforderung akzeptiert.

Sie könnten fragen: Welcher HTTP-Client (z. B. Browser) kann eine Anfrage senden, bei der dieser Header fehlt? Das HTTP-Protokoll ist sehr trivial. Sie können eine HTTP-Anforderung in wenigen Codezeilen erstellen, um keinen Host-Header zu senden. Wenn Sie jedes Mal eine fehlerhafte Anforderung erhalten, wird eine Ausnahme ausgelöst. Je nachdem, wie Sie mit solchen Ausnahmen umgehen, kann dies Ihren Server herunterfahren.

Überprüfen Sie also immer alle Eingaben . Dies ist keine Paranoia. Ich habe Anfragen erhalten, denen der Host-Header in meinem Dienst fehlt.

Außerdem behandeln nie URLs als Strings . Verwenden Sie das Knoten-URL-Modul, um bestimmte Teile einer Zeichenfolge zu ändern. Das Behandeln von URLs als Zeichenfolgen kann auf viele verschiedene Arten ausgenutzt werden. Tu es nicht.

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

app.get('*',function (req, res) {
    res.redirect('https://<domain>' + req.url);
});

app.listen(80);

Dies ist, was wir verwenden und es funktioniert großartig!

Sie können das "net" -Modul verwenden, um auf HTTP und HTTPS am selben Port zu warten

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

var net=require('net');
var handle=net.createServer().listen(8000)

var options = {
  key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
  cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
};

https.createServer(options, function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}).listen(handle);

http.createServer(function(req,res){
  res.writeHead(200);
  res.end("hello world\n");
}).listen(handle)

Das hat bei mir funktioniert:

app.use(function(req,res,next) {
    if(req.headers["x-forwarded-proto"] == "http") {
        res.redirect("https://[your url goes here]" + req.url, next);
    } else {
        return next();
    } 
});

Sie können 2 Node.js-Server instanziieren - einen für HTTP und HTTPS

Sie können auch eine Setup-Funktion definieren, die beide Server ausführen, sodass Sie nicht viel doppelten Code schreiben müssen.

So habe ich es gemacht: (mit restify.js, sollte aber für express.js oder auch für den Knoten selbst funktionieren)

http://qugstart.com/blog/node-js/node-js-restify-server-with-both-http-and-https/

Das hat bei mir funktioniert:

/* Headers */
require('./security/Headers/HeadersOptions').Headers(app);

/* Server */
const ssl = {
    key: fs.readFileSync('security/ssl/cert.key'),
    cert: fs.readFileSync('security/ssl/cert.pem')
};
//https server
https.createServer(ssl, app).listen(443, '192.168.1.2' && 443, '127.0.0.1');
//http server
app.listen(80, '192.168.1.2' && 80, '127.0.0.1');
app.use(function(req, res, next) {
    if(req.secure){
        next();
    }else{
        res.redirect('https://' + req.headers.host + req.url);
    }
});

Empfehlen Sie, die Header hinzuzufügen, bevor Sie zu https umleiten

Wenn Sie dies tun:

curl http://127.0.0.1 --include

Du erhältst:

HTTP/1.1 302 Found
//
Location: https://127.0.0.1/
Vary: Accept
Content-Type: text/plain; charset=utf-8
Content-Length: 40
Date: Thu, 04 Jul 2019 09:57:34 GMT
Connection: keep-alive

Found. Redirecting to https://127.0.0.1/

Ich benutze Express 4.17.1