web-dev-qa-db-fra.com

Activation de HTTPS sur express.js

J'essaie de faire fonctionner HTTPS sur express.js pour le noeud, et je ne peux pas le comprendre.

Ceci est mon code app.js.

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

Lorsque je l'exécute, il semble ne répondre qu'aux demandes HTTP.

J'ai écrit une application HTTPS basée sur Vanilla node.js simple:

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

Et lorsque je lance cette application, il répond aux demandes HTTPS. Notez que je ne pense pas que toString () sur le résultat fs soit important, car j’ai utilisé des combinaisons des deux et toujours aucun es bueno.

MODIFIER POUR AJOUTER:

Pour les systèmes de production, il est probablement préférable d’utiliser Nginx ou HAProxy pour envoyer des requêtes proxy à votre application nodejs. Vous pouvez configurer nginx pour gérer les requêtes ssl et simplement parler http à votre nœud app.js. 

MODIFIER POUR AJOUTER (06/04/2015)

Pour les systèmes utilisant AWS, il vaut mieux utiliser EC2 Elastic Load Balancers pour gérer la terminaison SSL et autoriser le trafic HTTP régulier vers vos serveurs Web EC2. Pour plus de sécurité, configurez votre groupe de sécurité de sorte que seul le ELB soit autorisé à envoyer du trafic HTTP aux instances EC2, ce qui empêchera le trafic HTTP non chiffré externe de frapper vos ordinateurs.

node.jshttpsexpress
306
Alan

Dans express.js (depuis la version 3), vous devriez utiliser cette syntaxe:

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

De cette manière, vous fournissez un middleware express au serveur http/https natif.

Si vous souhaitez que votre application fonctionne sur les ports inférieurs à 1024, vous devez utiliser la commande Sudo (non recommandé) ou utiliser un proxy inverse (par exemple, nginx, haproxy).

536
codename-

J'ai rencontré un problème similaire avec le fait que SSL fonctionne sur un port autre que le port 443. Dans mon cas, j'avais un certificat de lot ainsi qu'un certificat et une clé. Le certificat d'ensemble est un fichier qui contient plusieurs certificats. Le noeud requiert que vous divisiez ces certificats en éléments distincts d'un tableau. 

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

Dans app.js, vous devez spécifier https et créer le serveur en conséquence. Assurez-vous également que le port que vous essayez d'utiliser autorise réellement le trafic entrant. 

24
eomoto

Points compris:

  1. Configuration SSL
    1. Dans config/local.js 
    2. Dans config/env/production.js

Gestion HTTP et WS

  1. L’application doit fonctionner sur HTTP en développement afin que nous puissions facilement déboguer notreapp. 
  2. L'application doit fonctionner sur HTTPS en production pour des raisons de sécurité.
  3. Les requêtes HTTP de production d'applications doivent toujours être redirigées vers https.

Configuration SSL

Dans Sailsjs, il y a deux façons de configurer tout le matériel. La première consiste à configurer dans le dossier de configuration avec chaque fichier séparé (comme la connexion à la base de données concernant les paramètres situés dans connections.js). Et en second lieu, configurez sur la structure de fichier de base de l’environnement, chaque fichier d’environnement se trouvant dans le dossier config/env et chaque fichier contenant les paramètres d’un env particulier.

Sails commence par regarder dans le dossier config/env puis attend avec impatience config/* .js

_ {Permet maintenant de configurer ssl dans config/local.js.

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;

Alternativement, vous pouvez aussi ajouter ceci dans config/env/production.js. (Cet extrait montre également comment gérer plusieurs certificats CARoot)

Ou dans 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')
    }
};

redirection http/https et ws/wss

Ici, ws est Web Socket et wss représente Secure Web Socket, car nous avons configuré ssl, puis maintenant http et ws, les deux requêtes sont sécurisées et transformées en https et wss respectivement.

Il existe de nombreuses sources de notre application qui recevront une requête, comme toute publication de blog ou de média social, mais notre serveur ne fonctionne que sur https. Par conséquent, chaque requête provenant de http donne l'erreur «Ce site ne peut pas être atteint» dans le navigateur du client. Et nous perdons le trafic de notre site Web. Nous devons donc rediriger la requête http vers https, les mêmes règles autorisant websocket, sinon socket échouera.

Nous devons donc exécuter le même serveur sur le port 80 (http) et rediriger toutes les demandes vers le port 443 (https). Commence par compiler le fichier config/bootstrap.js avant de lever le serveur. Ici, nous pouvons démarrer notre serveur express sur le port 80.

In config/bootstrap.js (Créer un serveur http et rediriger toutes les demandes vers https)

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

Maintenant, vous pouvez visiter http://www.votredomaine.com , il sera redirigé vers https://www.votredomaine.com

8
Nishchit Dhanani

C'est comme ça que ça marche pour moi. La redirection utilisée redirigera également tous les http normaux.

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

Utilisez greenlock-express: SSL gratuit, HTTPS automatisé

Greenlock gère l’émission et le renouvellement du certificat (via Let's Encrypt) et la redirection http => https, prête à l'emploi.

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

Regardez la démonstration QuickStart: https://youtu.be/e8vaR4CEZ5s

 

Pour localhost

Répondez simplement à cette question à l’avance car c’est une question de suivi courante:

Vous ne pouvez pas avoir de certificats SSL sur localhost. Cependant, vous pouvez utiliser quelque chose comme Telebit qui vous permettra d’exécuter des applications locales comme de véritables applications.

Vous pouvez également utiliser des domaines privés avec Greenlock via les défis DNS-01, mentionnés dans le README, ainsi que dans divers plugins le prenant en charge.

Ports non standard (c'est-à-dire n ° 80/443)

Lisez la note ci-dessus sur localhost - vous ne pouvez pas non plus utiliser des ports non standard avec Let's Encrypt.

Cependant, vous pouvez exposer vos ports internes non standard en tant que ports standard externes via port-forward, sni-route ou utiliser quelque chose comme Telebit qui effectue le routage SNI et le transfert/relais de port pour vous.

Vous pouvez également utiliser les défis DNS-01, auquel cas vous n'avez pas besoin d'exposer les ports et vous pouvez également sécuriser des domaines sur des réseaux privés de cette manière.

3
CoolAJ86

Ceci est moncode de travailpourexpress 4.0.

express 4.0 est très différent de 3.0 et d'autres. 

4.0 vous avez le fichier/bin/www, que vous allez ajouter https ici.

"npm start" est la méthode standard pour démarrer Express 4.0 Server.

la fonction readFileSync () doit utiliser__dirnameget le répertoire en cours

while require ()use ./fait référence au répertoire en cours.

Vous commencez par placer les fichiers private.key et public.cert dans le dossier/bin, Il s'agit du même dossier que le fichier WWW .

0
hoogw