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

Ceci est mon app.jscode.

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 requêtes HTTP.

J'ai écrit une node.jsapplication HTTPS simple à base de vanille :

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 quand je lance cette application, il ne répondre aux demandes HTTPS. Notez que je ne pense pas que le toString () sur le résultat fs importe, car j'ai utilisé des combinaisons des deux et toujours pas d'es bueno.

MODIFIER POUR AJOUTER:

Pour les systèmes de production, vous feriez probablement mieux d'utiliser Nginx ou HAProxy pour proxy des requêtes vers votre application nodejs. Vous pouvez configurer nginx pour gérer les requêtes SSL et parler simplement http à votre nœud app.js.

MODIFIER POUR AJOUTER (4/6/2015)

Pour les systèmes utilisant AWS, il vaut mieux utiliser les équilibreurs de charge élastiques EC2 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 l'ELB soit autorisé à envoyer du trafic HTTP vers les instances EC2, ce qui empêchera le trafic HTTP non chiffré externe de toucher vos machines.

Dans express.js (depuis la version 3), vous devez 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 façon, vous fournissez un middleware express au serveur http / https natif

Si vous souhaitez que votre application s'exécute sur des ports inférieurs à 1024, vous devrez utiliser la sudocommande (non recommandée) ou utiliser un proxy inverse (par exemple nginx, haproxy).

Tout d'abord, vous devez créer des fichiers selfsigned.key et selfsigned.crt . Accédez à Créer un certificat SSL auto-signé ou procédez comme suit.

Accédez au terminal et exécutez la commande suivante.

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout ./selfsigned.key -out selfsigned.crt

• Après cela, mettez les informations suivantes
• Nom du pays (code à 2 lettres) [AU]: US
• Nom de l'État ou de la province (nom complet) [Quel État]: NY
• Nom de localité (par exemple, ville) []: NY
• Nom de l'organisation (par exemple, société) [Internet Widgits Pty Ltd]: xyz (Votre - Organisation)
• Nom de l'unité organisationnelle (par exemple, section) []: xyz (nom de votre unité)
• Nom commun (par exemple nom de domaine complet du serveur ou VOTRE nom) []: www.xyz.com (votre URL)
• Adresse e-mail []: votre adresse e-mail

Après la création, ajoute le fichier key & cert dans votre code et transmettez les options au serveur.

const express = require('express');
const https = require('https');
const fs = require('fs');
const port = 3000;

var key = fs.readFileSync(__dirname + '/../certs/selfsigned.key');
var cert = fs.readFileSync(__dirname + '/../certs/selfsigned.crt');
var options = {
  key: key,
  cert: cert
};

app = express()
app.get('/', (req, res) => {
   res.send('Now using https..');
});

var server = https.createServer(options, app);

server.listen(port, () => {
  console.log("server starting on port : " + port)
});

• Enfin, exécutez votre application en utilisant https .

Plus d'informations https://github.com/sagardere/set-up-SSL-in-nodejs

J'ai rencontré un problème similaire avec l'obtention de SSL pour travailler sur un port autre que le port 443. Dans mon cas, j'avais un certificat de bundle ainsi qu'un certificat et une clé. Le certificat de bundle est un fichier qui contient plusieurs certificats, le nœud nécessite 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.

Y compris les points:

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 cours de développement afin que nous puissions facilement déboguer notre application.
2. L'application doit fonctionner sur HTTPS en production pour des raisons de sécurité.
3. La demande HTTP de production d'application doit toujours être redirigée vers https.

Configuration SSL

Dans Sailsjs, il y a deux façons de configurer toutes les choses, la première consiste à configurer dans le dossier config avec chacun a ses fichiers séparés (comme la connexion à la base de données concernant les paramètres se trouve dans connections.js). Et le second est de configurer la structure de fichier de base de l'environnement, chaque fichier d'environnement se présente dansconfig/env dossier et chaque fichier contient des paramètres pour un environnement particulier.

Sails regarde d'abord dans le dossier config / env puis attend avec impatience config / * .js

Permet maintenant de configurer ssl 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 également l'ajouter 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 & ws / wss

Ici, ws est Web Socket et wss représente Secure Web Socket, car nous configurons ssl puis maintenant http et ws les deux demandes deviennent sécurisées et se transforment respectivement en https et wss.

Il existe de nombreuses sources de notre application qui recevront une demande comme tout article de blog, publication sur les réseaux sociaux, mais notre serveur ne fonctionne que sur https, donc lorsque toute demande provient de http, il affiche l'erreur "Ce site est inaccessible" 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 autorisent le websocket sinon le socket échouera.

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

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

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

Utilisez greenlock-express: SSL gratuit, HTTPS automatisé

Greenlock gère l'émission et le renouvellement des certificats (via Let's Encrypt) et la redirection http => https, .

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: 'john.doe@example.com'
, 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épondre à 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 vraies.

Vous pouvez également utiliser des domaines privés avec Greenlock via des défis DNS-01, qui sont mentionnés dans le README avec divers plugins qui le prennent en charge.

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

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

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

Vous pouvez également utiliser des défis DNS-01, auquel cas vous n'aurez pas besoin d'exposer les ports du tout et vous pouvez également sécuriser des domaines sur des réseaux privés de cette façon.

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

Ceci est mon code de travail pour express 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 manière standard de démarrer le serveur express 4.0.

La fonction readFileSync () doit utiliser __dirname obtenir le répertoire courant

tandis que require () utilise ./ réfère au répertoire courant.

Vous mettez d'abord le fichier private.key et public.cert dans le dossier / bin, c'est le même dossier que le fichier WWW .