Automatyczne połączenie / przekierowanie HTTPS z node.js / express

Próbowałem skonfigurować protokół HTTPS z projektem node.js, nad którym pracuję. Zasadniczo postępowałem zgodnie z dokumentacją node.js dla tego przykładu:

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

Teraz, kiedy to zrobię

curl -k https://localhost:8000/

dostaję

hello world

zgodnie z oczekiwaniami. Ale jeśli to zrobię

curl -k http://localhost:8000/

dostaję

curl: (52) Empty reply from server

Z perspektywy czasu wydaje się to oczywiste, że to zadziała w ten sposób, ale jednocześnie ludzie, którzy ostatecznie odwiedzą mój projekt, nie będą wpisywać https : // yadayada, a ja chcę, aby cały ruch był https od momentu, w którym trafią Strona.

Jak mogę sprawić, aby węzeł (i Express, ponieważ jest to platforma, której używam), przekazywał cały ruch przychodzący do https, niezależnie od tego, czy został określony, czy nie? Nie udało mi się znaleźć żadnej dokumentacji, która dotyczyłaby tego. A może po prostu zakłada się, że w środowisku produkcyjnym node ma coś, co znajduje się przed nim (np. Nginx), co obsługuje tego rodzaju przekierowanie?

To moja pierwsza przygoda z tworzeniem stron internetowych, więc proszę wybacz moją ignorancję, jeśli jest to coś oczywistego.

Ryan, dzięki za wskazanie mi właściwego kierunku. Uzupełniłem twoją odpowiedź (akapit drugi) trochę kodem i działa. W tym scenariuszu te fragmenty kodu są umieszczane w mojej aplikacji ekspresowej:

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

Serwer https express nasłuchuje ATM na 3000. Ustawiłem te reguły iptables, aby węzeł nie musiał działać jako root:

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

Wszystko razem działa dokładnie tak, jak chciałem.

Jeśli podążasz za konwencjonalnymi portami, ponieważ HTTP domyślnie próbuje portu 80, a HTTPS domyślnie próbuje portu 443, możesz po prostu mieć dwa serwery na tej samej maszynie: Oto kod:

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

Testuj za pomocą https:

$ curl https://127.0.0.1 -k
secure!

Z 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

Więcej szczegółów: Nodejs HTTP i HTTPS przez ten sam port

Dzięki temu facetowi: 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);
        }
});

Dzięki Nginx możesz skorzystać z nagłówka „x-forwarded-proto”:

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

Od 0.4.12 nie mamy prawdziwego, czystego sposobu nasłuchiwania HTTP i HTTPS na tym samym porcie przy użyciu serwerów HTTP / HTTPS węzła.

Niektórzy ludzie rozwiązali ten problem, mając serwer HTTPS Node (działa to również z Express.js) nasłuchujący 443 (lub jakiś inny port), a także mając mały serwer http, który łączy się z 80 i przekierowuje użytkowników do bezpiecznego portu.

Jeśli absolutnie musisz mieć możliwość obsługi obu protokołów na jednym porcie, musisz umieścić nginx, lighttpd, apache lub inny serwer WWW na tym porcie i działać jako zwrotne proxy dla Node.

Możesz użyć modułu express-force-https :

npm install --save express-force-https

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

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

Korzystam z rozwiązania zaproponowanego przez Basarata, ale muszę też nadpisać port, ponieważ miałem 2 różne porty dla protokołów HTTP i HTTPS.

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

Wolę również używać niestandardowego portu, aby uruchomić nodejs bez uprawnień roota. Lubię 8080 i 8443, ponieważ pochodzę z wielu lat programowania na tomcat.

Mój kompletny plik to

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

Następnie używam iptable do formułowania ruchu 80 i 443 na moich portach HTTP i HTTPS.

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

Ta odpowiedź musi zostać zaktualizowana, aby działała z Express 4.0. Oto jak uruchomiłem oddzielny serwer http:

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

Jeśli Twoja aplikacja znajduje się za zaufanym proxy (np. AWS ELB lub poprawnie skonfigurowanym nginx), ten kod powinien działać:

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

Uwagi:

• Zakłada się, że hostujesz swoją witrynę na 80 i 443, jeśli nie, musisz zmienić port podczas przekierowania
• Zakłada się również, że zamykasz SSL na serwerze proxy. Jeśli robisz SSL od końca do końca, użyj odpowiedzi z @basarat powyżej. Lepszym rozwiązaniem jest protokół SSL typu end-to-end.
• app.enable ('trust proxy') umożliwia ekspresowe sprawdzenie nagłówka X-Forwarded-Proto

Uważam, że req.protocol działa, gdy używam express (nie testowałem bez, ale podejrzewam, że działa). przy użyciu bieżącego węzła 0.10.22 z wyrażeniem 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();
  } 
});

Większość odpowiedzi sugeruje użycie nagłówka req.headers.host.

Nagłówek hosta jest wymagany przez HTTP 1.1, ale w rzeczywistości jest opcjonalny, ponieważ nagłówek może nie zostać wysłany przez klienta HTTP, a węzeł / express zaakceptuje to żądanie.

Możesz zapytać: który klient HTTP (np. Przeglądarka) może wysłać żądanie bez tego nagłówka? Protokół HTTP jest bardzo trywialny. Możesz utworzyć żądanie HTTP w kilku wierszach kodu, aby nie wysyłać nagłówka hosta, a jeśli za każdym razem, gdy otrzymasz zniekształcone żądanie, zgłosisz wyjątek i w zależności od tego, jak obsłużysz takie wyjątki, może to spowodować wyłączenie serwera.

Dlatego zawsze sprawdzaj poprawność wszystkich danych wejściowych . To nie jest paranoja, otrzymałem żądania bez nagłówka hosta w mojej usłudze.

Nigdy też nie traktuj adresów URL jako ciągów . Użyj modułu node url, aby zmodyfikować określone części ciągu. Traktowanie adresów URL jako ciągów znaków można wykorzystać na wiele różnych sposobów. Nie rób tego.

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

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

app.listen(80);

Tego używamy i działa świetnie!

możesz użyć modułu "net" do nasłuchiwania HTTP i HTTPS na tym samym porcie

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)

To zadziałało dla mnie:

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

Możesz utworzyć instancję 2 serwerów Node.js - jeden dla HTTP i HTTPS

Możesz także zdefiniować funkcję konfiguracyjną, którą będą wykonywać oba serwery, dzięki czemu nie musisz pisać zbyt wielu zduplikowanych kodów.

Oto sposób, w jaki to zrobiłem: (używając restify.js, ale powinno działać dla express.js lub samego węzła)

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

To zadziałało dla mnie:

/* 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);
    }
});

Zalecamy dodanie nagłówków przed przekierowaniem do https

Teraz, kiedy to zrobisz:

curl http://127.0.0.1 --include

Dostajesz:

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/

Używam express 4.17.1