Connexion / redirection HTTPS automatique avec node.js / express

J'ai essayé de configurer HTTPS avec un projet node.js sur lequel je travaille. J'ai essentiellement suivi la documentation de node.js pour cet exemple:

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

Maintenant, quand je fais

curl -k https://localhost:8000/

Je reçois

hello world

comme prévu. Mais si je fais

curl -k http://localhost:8000/

Je reçois

curl: (52) Empty reply from server

Rétrospectivement, cela semble évident que cela fonctionnerait de cette façon, mais en même temps, les personnes qui finissent par visiter mon projet ne vont pas taper https : // yadayada, et je veux que tout le trafic soit https à partir du moment où ils arrivent. le site.

Comment puis-je obtenir node (et Express car c'est le framework que j'utilise) pour transférer tout le trafic entrant vers https, qu'il ait été spécifié ou non? Je n'ai pu trouver aucune documentation traitant de cela. Ou est-il simplement supposé que dans un environnement de production, un nœud a quelque chose devant lui (par exemple nginx) qui gère ce type de redirection?

C'est ma première incursion dans le développement Web, alors pardonnez mon ignorance si c'est quelque chose d'évident.

Ryan, merci de m'avoir pointé dans la bonne direction. J'ai étoffé un peu votre réponse (2ème paragraphe) avec du code et cela fonctionne. Dans ce scénario, ces extraits de code sont placés dans mon application express:

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

Le serveur https express écoute ATM sur 3000. J'ai configuré ces règles iptables afin que le nœud n'ait pas à s'exécuter en tant que 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

Dans l'ensemble, cela fonctionne exactement comme je le voulais.

Si vous suivez les ports conventionnels puisque HTTP essaie le port 80 par défaut et HTTPS essaie le port 443 par défaut, vous pouvez simplement avoir deux serveurs sur la même machine: Voici le 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);

Tester avec https:

$ curl https://127.0.0.1 -k
secure!

Avec 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

Plus de détails: Nodejs HTTP et HTTPS sur le même port

Merci à ce gars: 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);
        }
});

Avec Nginx, vous pouvez profiter de l'en-tête "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);  
}

Depuis la version 0.4.12, nous n'avons pas vraiment de moyen propre d'écouter HTTP et HTTPS sur le même port en utilisant les serveurs HTTP / HTTPS de Node.

Certaines personnes ont résolu ce problème en demandant au serveur HTTPS de Node (cela fonctionne également avec Express.js) d'écouter 443 (ou d'un autre port) et d'avoir également un petit serveur http lié à 80 et de rediriger les utilisateurs vers le port sécurisé.

Si vous devez absolument être capable de gérer les deux protocoles sur un seul port, vous devez mettre nginx, lighttpd, apache ou un autre serveur Web sur ce port et agir en tant que proxy inverse pour Node.

Vous pouvez utiliser le module 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);

J'utilise la solution proposée par Basarat mais j'ai aussi besoin d'écraser le port car j'avais l'habitude d'avoir 2 ports différents pour les protocoles HTTP et HTTPS.

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

Je préfère également utiliser un port non standard pour démarrer nodejs sans privilèges root. J'aime 8080 et 8443 parce que je viens de beaucoup d'années de programmation sur tomcat.

Mon dossier complet devient

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

Ensuite, j'utilise iptable pour forwording 80 et 443 trafic sur mes ports HTTP et 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

Cette réponse doit être mise à jour pour fonctionner avec Express 4.0. Voici comment j'ai fait fonctionner le serveur http séparé:

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

Si votre application se trouve derrière un proxy de confiance (par exemple, un AWS ELB ou un nginx correctement configuré), ce code devrait fonctionner:

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

Remarques:

• Cela suppose que vous hébergez votre site sur 80 et 443, sinon, vous devrez changer le port lorsque vous redirigez
• Cela suppose également que vous mettez fin au SSL sur le proxy. Si vous faites du SSL de bout en bout, utilisez la réponse de @basarat ci-dessus. Le SSL de bout en bout est la meilleure solution.
• app.enable ('trust proxy') permet à express de vérifier l'en-tête X-Forwarded-Proto

Je trouve que req.protocol fonctionne lorsque j'utilise express (je n'ai pas testé sans mais je soupçonne que cela fonctionne). en utilisant le nœud actuel 0.10.22 avec 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();
  } 
});

La plupart des réponses ici suggèrent d'utiliser l'en-tête req.headers.host.

L'en-tête Host est requis par HTTP 1.1, mais il est en fait facultatif puisque l'en-tête peut ne pas être réellement envoyé par un client HTTP, et node / express acceptera cette demande.

Vous pourriez demander: quel client HTTP (par exemple: navigateur) peut envoyer une requête sans cet en-tête? Le protocole HTTP est très simple. Vous pouvez créer une requête HTTP en quelques lignes de code, pour ne pas envoyer d'en-tête d'hôte, et si chaque fois que vous recevez une requête malformée, vous lancez une exception, et selon la façon dont vous gérez ces exceptions, cela peut arrêter votre serveur.

Alors validez toujours toutes les entrées . Ce n'est pas de la paranoïa, j'ai reçu des demandes sans en-tête d'hôte dans mon service.

De plus, ne traitez jamais les URL comme des chaînes . Utilisez le module URL du nœud pour modifier des parties spécifiques d'une chaîne. Traiter les URL comme des chaînes peut être exploité de nombreuses manières. Ne fais pas ça.

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

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

app.listen(80);

C'est ce que nous utilisons et cela fonctionne très bien!

vous pouvez utiliser le module "net" pour écouter HTTP et HTTPS sur le même port

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)

Cela a fonctionné pour moi:

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

Vous pouvez instancier 2 serveurs Node.js - un pour HTTP et HTTPS

Vous pouvez également définir une fonction de configuration que les deux serveurs exécuteront, de sorte que vous n'ayez pas à écrire beaucoup de code dupliqué.

Voici comment je l'ai fait: (en utilisant restify.js, mais devrait fonctionner pour express.js, ou le nœud lui-même aussi)

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

Cela a fonctionné pour moi:

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

Recommander d'ajouter les en-têtes avant de rediriger vers https

Maintenant, quand vous faites:

curl http://127.0.0.1 --include

Vous obtenez:

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/

J'utilise express 4.17.1