Erreur HTTPS

Bonjour,
J’ai rejoins une association de mon école qui est en train de se développer un petit intranet. Ils utilisent NodeJS avec Express JS. Pour les aider, j’ai créé un Vagrant, qui permet de développer dans un environnement beaucoup plus adapté. J’ai un problème cependant avec les certificats HTTPS, c’est quelque chose que je ne connais pas du tout. En faisant mon git clone, j’ai téléchargé le projet dont le dossier avec les certificats, qui sont ensuite ajouté à Express. On a ce simple routing qui permet de tester que tout va bien :

1
2
3
4

app.get('/', function (req, res) {
  res.send("This server works !")
  return;
});

En me connectant à https://localhost:8080, j’obtient la page comme quoi la connexion n’est pas sécurisée, erreur : NET::ERR_CERT_AUTHORITY_INVALID. En me renseignant, j’apprend que mes certificats ne sont pas valides, hors ils fonctionnent pour les autres dev de l’asso ! En choisissant d’ignorer cet avertissement, j’obtient : Cannot GET /.

Quelqu’un pourrait m’aider ? Merci !

(Disclaimer : je suis loin d’être un expert) Tu passes par un logiciel comme nginx ou Apache avant ton application ?

• Si oui c’est probablement qu’il faut les configurer
• Si non, est-ce que tu peux montrer le code qui lance l’application (quelque chose comme app.run() ou similaire, car par défaut je pense que ça ne doit pas être prévu pour de l’HTTPS

Avec nodejs et les certificats HTTPS j’utilise letencrypt et son extension de validation/prolongation automatique du certificat.

Le module letsencrypt avec Express est génial tu as besoin de rien faire à part paramétrer 4 lignes.

Je plussoie Situphen. Tu peux mettre faire écouter Node.js directement en HTTPS mais c’est pas ce que je fais ni ce que je conseillerais de faire. À mon avis, c’est nettement plus simple de mettre le HTTPS au niveau du reverse proxy (Apache, nginx ou autre) et de laisser Node.js écouter en HTTP.

Merci à vous pour vos réponses. J’avoue que y’a pas mal de choses dans leur code que je ne comprend pas tout a fait, il faut vraiment que je m’y penche. Mais voici ce qui fait tout le serveur :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

var express = require('express');               // Web server
var fs      = require('fs');                    // File system
var https   = require('https');                 // Secure HTTP protocol
var mysql   = require('mysql');                 // Database interface
var bodyParser = require('body-parser');        // X-form-data decoder
var crypto = require('crypto');                 // Cryptography 
var helmet = require('helmet');                 // Web server safety
var session = require('express-session');       // Session management
var redis = require('connect-redis')(session);  // Session store
var cors = require('cors')                      // Cross Origin Resource Sharing

// Configuration
    // Check if the executable has been started with the "prod" argument
    // Like this : "node server.js prod" or "./server.js prod"
var localhost = (process.argv[2] != "prod");
var port  = 8080;
// HTTPS
    // Choose the right certificate depending on the evironment
if( !localhost ) {
    var privateKey  = fs.readFileSync('sslcert/private.key', 'utf8');
    var certificate = fs.readFileSync('sslcert/certificate.crt', 'utf8');
} else {
    var privateKey  = fs.readFileSync('sslcert/localhost.key', 'utf8');
    var certificate = fs.readFileSync('sslcert/localhost.crt', 'utf8');
}

var credentials = {key: privateKey, cert: certificate};


// Initialization
    // Express application
var app = express()
    // HTTPS web server
var server = https.createServer(credentials, app);

    // POST parser
app.use(bodyParser.urlencoded({extended: true}));
    // CORS headers
function getOrigin(origin, cb) {cb(null, true);}
app.use(cors({origin : getOrigin, credentials : true}));

app.set('trust proxy', 1); // trust first proxy

// Routing
    /* test */
app.get('/', function (req, res) {
    res.send("This server works !")
    return;
});


app.options('*', cors({origin : getOrigin, credentials: true})) // Pre-flight

// Listening
server.listen(port, function () {
  console.log('Backend server listening on port '+port);
});

J’ai également oublié de préciser que j’ai tester en HTTP et ça fonctionne correctement.

Tu passes par un logiciel comme nginx ou Apache avant ton application ?

Du coup non, le serveur est entièrement sous node.

Je plussoie Situphen. Tu peux mettre faire écouter Node.js directement en HTTPS mais c’est pas ce que je fais ni ce que je conseillerais de faire. À mon avis, c’est nettement plus simple de mettre le HTTPS au niveau du reverse proxy (Apache, nginx ou autre) et de laisser Node.js écouter en HTTP.

C’est sûrement plus simple, mais eux on choisi de laisser Node.js écouter en HTTPS. Il va falloir s’y adapter.

J’ai trouvé l’erreur, je pense. HTTPS utilise le port 443 et je ne l’avais configuré dans le vagrantfile. Du coup j’ai ajouté cette ligne :

1

config.vm.network "forwarded_port", guest: 443, host: 8443, host_ip: "127.0.0.1"

Mais maintenant il faut que j’indique à Windows de rediriger les connexions au port 443 au 8443 de localhost non ?

Mais maintenant il faut que j’indique à Windows de rediriger les connexions au port 443 au 8443 de localhost non ?

Euh non, normalement t’as juste à aller sur https://localhost:8443. Mais normalement tu peux très bien faire écouter Vagrant sur le port 443 (avec guest: 443, host: 443) et aller ainsi sur https://localhost.

(Bon, je ne connais pas trop Vagrant mais je fais tout le temps des trucs équivalents avec Docker)

Euh non, normalement t’as juste à aller sur https://localhost:8443

Le serveur node écoute 8080, donc aller sur https://localhost:8443 va en vrai aller sur 443.. Du coup le 8080 ne reçoit rien, la page me dit juste que ma connexion a été réinitialisée (pas d’erreur de certificats).

Mais normalement tu peux très bien faire écouter Vagrant sur le port 443

1
2
3
4
5

==> default: You are trying to forward to privileged ports (ports <= 1024). Most
==> default: operating systems restrict this to only privileged process (typically
==> default: processes running as an administrative user). This is a warning in case
==> default: the port forwarding doesn't work. If any problems occur, please try a
==> default: port higher than 1024.

Il a pas l’air d’apprécier. Sur de nombreux blogs que j’ai pus lire, ils partent bien du 8443 et ensuite indique à l’OS de rediriger 443 sur 8443. Le problème c’est que tous les posts que j’ai croisé sont sur Mac OSX, pas un seul sous Windows..

Okay. Mais si dans la VM, Node.js écoute sur 8080 au lieu de 443, il faut que tu le dises à Vagrant sinon ça ne peut pas marcher :

1

config.vm.network "forwarded_port", guest: 8080, host: 8443, host_ip: "127.0.0.1"

Et là, tu devrais pouvoir naviger sur https://localhost:8443.

Du coup j’ai fait quelque chose comme ça :

1
2

config.vm.network "forwarded_port", guest: 443, host: 8443, host_ip: "127.0.0.1"
config.vm.network "forwarded_port", guest: 8080, host: 8443, host_ip: "127.0.0.1"

Vagrant ne forward que le dernier port, un port ne peut pas avoir deux valeurs si?

Pour info, mon vagrantfile ressemble à ceci :

1
2
3
4
5
6
7
8
9

Vagrant.configure("2") do |config|
  config.vm.box = "bento/ubuntu-17.04"
  config.vm.network "forwarded_port", guest: 443, host: 8443, host_ip: "127.0.0.1"
  config.vm.network "forwarded_port", guest: 8080, host: 8443, host_ip: "127.0.0.1"

  config.vm.synced_folder "../dev", "/home/vagrant/Project"

  config.vm.provision "shell", path: "../dev/configure"
end

Je ne vois pas comment ceci peut marcher :

1
2

config.vm.network "forwarded_port", guest: 443, host: 8443, host_ip: "127.0.0.1"
config.vm.network "forwarded_port", guest: 8080, host: 8443, host_ip: "127.0.0.1"

Tu devrais avoir une erreur de Vagrant du genre “bind failed. Error: Address already in use”.

Mais t’as bien modifié ton programme pour que Node.js écoute à la fois sur le port 443 et 8080 ?

C’est bien ce qu’il me semblait, ça ne peut pas fonctionner.

Mais t’as bien modifié ton programme pour que Node.js écoute à la fois sur le port 443 et 8080 ?

Pas du tout, mais normalement je ne devrais pas à avoir à le faire, le serveur fonctionne très bien sous un Linux sans passer par une machine virtuelle. C’est juste un problème de configuration de vagrant non?

Ouais. Normalement, tu ne devrais avoir qu’une seule ligne forwaded_port, où guest indique le port sur lequel écoute Node.js (dans la VM) et host indique le port sur ton hôte (en dehors de la VM). C’est de la translation de port.

Note qu’à priori, tu peux très bien utiliser le même numéro de port sur l’hôte et sur la VM. C’est pas les mêmes interfaces réseau donc ça ne gène pas. Mais tu ne peux pas bind() deux fois sur le même port et la même adresse. Tu vois le délire ?

Oui j’ai très bien compris ça, ça me semble logique.

Le truc c’est que pour HTTPS, on a besoin de deux ports non? Le 80 et le 443

Comment faire du coup pour que ça fonctionne ?

Non. Le HTTPS n’a pas besoin du port 80 pour fonctionner. Par contre, si tu veux que le serveur réponde en HTTP ne serait-ce que pour rediriger en HTTPS, il te faudra un second port (pour le HTTP).