Node.js / express ile otomatik HTTPS bağlantısı / yönlendirme

Üzerinde çalıştığım bir node.js projesi ile HTTPS kurmaya çalışıyorum. Aslında bu örnek için node.js belgelerini izledim :

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

Şimdi, yaptığımda

curl -k https://localhost:8000/

alırım

hello world

beklenildiği gibi. Ama eğer yaparsam

curl -k http://localhost:8000/

alırım

curl: (52) Empty reply from server

Geriye dönük olarak bu, bu şekilde çalışacağı açık gibi görünüyor, ancak aynı zamanda projemi sonunda ziyaret eden insanlar https : // yadayada yazmayacaklar ve tüm trafiğin vuruldukları andan itibaren https olmasını istiyorum site.

Belirtilmiş olup olmadığına bakılmaksızın, gelen tüm trafiği https'ye dağıtmak için düğümü (ve kullandığım çerçeve olduğu gibi Express'i) nasıl alabilirim? Bunu ele alan herhangi bir belge bulamadım. Yoksa sadece bir üretim ortamında, düğümün önünde bu tür bir yönlendirmeyi işleyen bir şey (örneğin, nginx) olduğu var mı?

Bu benim web geliştirmeye ilk adımım, bu yüzden bu bariz bir şeyse lütfen cehaletimi affet.

Ryan, beni doğru yöne yönlendirdiğin için teşekkürler. Cevabınızı (2. paragraf) biraz kodla ettim ve işe yarıyor. Bu senaryoda bu kod parçacıkları benim ekspres app koymak:

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

Https ekspres sunucusu ATM'yi 3000'de dinler. Düğümün root olarak çalışması gerekmeyecek şekilde bu iptables kurallarını ayarladım:

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

Hep birlikte, bu tam istediğim gibi çalışıyor.

HTTP varsayılan olarak 80 numaralı bağlantı noktasını denediğinden ve HTTPS varsayılan olarak 443 numaralı bağlantı noktasını denediğinden geleneksel bağlantı noktalarını izlerseniz, aynı makinede iki sunucunuz olabilir: İşte 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);

Https ile test edin:

$ curl https://127.0.0.1 -k
secure!

Http ile:

$ 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

Daha fazla detay: Aynı bağlantı noktası üzerinden Nodejs HTTP ve HTTPS

Bu adam için teşekkürler: 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);
        }
});

Nginx ile "x-forwarded-proto" başlığından yararlanabilirsiniz:

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

0.4.12'den itibaren Düğümün HTTP / HTTPS sunucularını kullanarak aynı bağlantı noktasında HTTP ve HTTPS dinlemenin gerçek temiz bir yolu yoktur.

Bazı insanlar Node'nin HTTPS sunucusunu (bu Express.js ile de çalışır) 443'ü (veya başka bir bağlantı noktasını) dinleyerek ve ayrıca 80'e bağlanan ve kullanıcıları güvenli bağlantı noktasına yönlendiren küçük bir http sunucusuna sahip olarak bu sorunu çözdüler.

Kesinlikle tek bir bağlantı noktasında her iki protokolü de kullanabilmeniz gerekiyorsa, o bağlantı noktasına nginx, lighttpd, apache veya başka bir web sunucusu koymanız ve Düğüm için ters proxy olarak davranmanız gerekir.

Sen kullanabilirsiniz ekspres-kuvvet-https modülü:

npm install --save express-force-https

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

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

Basarat tarafından önerilen çözümü kullanıyorum, ancak HTTP ve HTTPS protokolleri için 2 farklı bağlantı noktasına sahip olduğum için bağlantı noktasının üzerine yazmam gerekiyor.

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

Ben de kök ayrıcalıkları olmadan nodejs başlatmak için standart port kullanmayı tercih ederim. 8080 ve 8443'ü seviyorum çünkü tomcat üzerinde yıllarca süren programlardan geldim.

Tam dosyam oldu

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

Sonra HTTP ve HTTPS bağlantı noktalarımda 80 ve 443 trafiğini önceden yazmak için iptable kullanıyorum.

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

Express 4.0 ile çalışmak için bu yanıtın güncellenmesi gerekir. İşte nasıl çalışmak için ayrı http sunucusu var:

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

Uygulamanız güvenilir bir proxy'nin arkasındaysa (örn. AWS ELB veya doğru yapılandırılmış bir nginx), bu kodun çalışması gerekir:

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

Notlar:

• Bu, sitenizi 80 ve 443'te barındırdığınızı varsayarsa, yeniden yönlendirdiğinizde bağlantı noktasını değiştirmeniz gerekir
• Bu ayrıca proxy'deki SSL'yi sonlandırdığınızı varsayar. Uçtan uca SSL yapıyorsanız, yukarıdaki @basarat'ın yanıtını kullanın. Uçtan uca SSL daha iyi bir çözümdür.
• app.enable ('trust proxy'), express'in X-Forwarded-Proto başlığını kontrol etmesini sağlar

Ben ekspres kullandığımda req.protocol çalışır buluyorum (olmadan test etmedim ama çalışır şüpheli). ifade 3.4.3 ile geçerli düğüm 0.10.22 kullanma

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

Buradaki yanıtların çoğu req.headers.host üstbilgisini kullanmanızı önerir.

Ana bilgisayar üstbilgisi HTTP 1.1 tarafından zorunludur, ancak üstbilgi aslında bir HTTP istemcisi tarafından gönderilmeyebileceğinden ve düğüm / ifade bu isteği kabul edeceğinden aslında isteğe bağlıdır.

Şunları sorabilirsiniz: Hangi HTTP istemcisi (örneğin: tarayıcı) bu üstbilgiyi eksik bir istek gönderebilir? HTTP protokolü çok önemsizdir. Bir ana bilgisayar üstbilgisi göndermemek için birkaç kod satırında bir HTTP isteği oluşturabilirsiniz ve hatalı biçimlendirilmiş her istek aldığınızda bir istisna atarsınız ve bu tür istisnaları nasıl ele aldığınıza bağlı olarak bu sunucunuzu devre dışı bırakabilir.

Bu yüzden her zaman tüm girdileri doğrulayın . Bu paranoya değil, hizmetimde ana bilgisayar üstbilgisi eksik istekleri aldım.

Ayrıca, URL'lere asla dizgi olarak davranmayın . Bir dizenin belirli bölümlerini değiştirmek için düğüm url modülünü kullanın. URL'leri dize olarak ele almak birçok farklı şekilde kullanılabilir. Yapma.

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

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

app.listen(80);

Kullandığımız şey bu ve harika çalışıyor!

aynı portta HTTP ve HTTPS dinlemek için "net" modülünü kullanabilirsiniz

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)

Bu benim için çalıştı:

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

HTTP ve HTTPS için bir tane olmak üzere 2 Node.js sunucusu başlatabilirsiniz

Ayrıca, her iki sunucunun da çalıştıracağı bir kurulum işlevi tanımlayabilirsiniz, böylece çok fazla çoğaltılmış kod yazmak zorunda kalmazsınız.

İşte bunu yapmanın yolu: (restify.js kullanarak, ancak express.js veya düğümün kendisi için de çalışmalıdır)

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

Bu benim için çalıştı:

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

Https'ye yönlendirmeden önce üstbilgileri eklemenizi öneririz

Şimdi, yaptığınız zaman:

curl http://127.0.0.1 --include

Şunları elde edersiniz:

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/

Express 4.17.1 kullanıyorum