NodeJs et SSL: une petite analyse

Le but de cet article est de faire un petit tour d'horizon de l'usage de SSL dans nos applications NodeJs, en l'occurence, quand nous souhaitons faire une application Web, une API REST, ou les deux.

Nous allons avoir 6 étapes pour de réalisation d'un serveur NodeJs, avec à chaque fois 12 clients:
  • Un client NodeJs sans certificats SSL - strictSSL à false
  • Un client NodeJs sans certificats SSL - strictSSL à true
  • Un client NodeJs avec un certificat SSL client non fiable - strictSSL à false
  • Un client NodeJs avec un certificat SSL client non fiable - strictSSL à true
  • Un client NodeJs avec un certificat SSL server non fiable - strictSSL à false
  • Un client NodeJs avec un certificat SSL server non fiable - strictSSL à true
  • Un client NodeJs avec un certificat SSL client fiable - strictSSL à false
  • Un client NodeJs avec un certificat SSL client fiable - strictSSL à true
  • Un client NodeJs avec un certificat SSL serveur fiable - strictSSL à false
  • Un client NodeJs avec un certificat SSL serveur fiable - strictSSL à true
  • Une application Web
  • Une requête Ajax dans une application Web

Les certificats SSL

Le certificat SSL non viable



Nous allons tout d'abord générer le CA:
> openssl genrsa -des3 -out ca.key 2048
> openssl req -new -x509 -days 365 -key ca.key -out ca.crt

Ensuite le certificat SSL serveur:
> openssl genrsa -out server.key 2048
> openssl req -new -key server.key -out server.csr
> openssl x509 -req -in server.csr -out server.crt -CA ca.crt -CAkey ca.key -CAcreateserial -days 365

Et enfin le certificat SSL client:
> openssl genrsa -out client.key 2048
> openssl req -new -key client.key -out client.csr
> openssl x509 -req -in client.csr -out client.crt -CA ca.crt -CAkey ca.key -CAcreateserial -days 365
> openssl verify -CAfile ca.crt client.crt

Le certificat SSL "viable"

Pour cela, je me suis inspirer du site suivant: http://engineering.circle.com/https-authorized-certs-with-node-js/.


Nous allons tout d'abord générer le CA:
> openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca.key -out ca.crt
> openssl genrsa -out server.key 4096

Ensuite le certificat SSL serveur:
> openssl req -new -config server.cnf -key server.key -out server.csr
> openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt

Et enfin le certificat SSL client:
> openssl genrsa -out client.key 4096
> openssl req -new -config client.cnf -key client.key -out client.csr
> openssl x509 -req -extfile client.cnf -days 999 -passin "pass:password" -in client.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out client.crt
> openssl verify -CAfile ca.crt client.crt

 Le serveur

Le serveur devra exposer sur l'url https://localhost:9000 nos ressources statiques, en l'occurence, notre page Web avec les JavaScripts / CSS associés.

Il devra également exposer sur l'url https://localhost:9000/api une API Rest très simpliste.

Pour nous aider, nous allons utiliser le module express afin de créer notre serveur Web, écrit en ES6.


L'API Rest

Comme vous pouvez le constater, il reste très simple (nous retournons un simple objet JSON). A noter toutefois que pour chaque appel sur l'API Rest, nous affichons si par rapport à la configuration du serveur, la requête est autorisé (si le certificat SSL fournit lors de la requête semble viable) et si oui, le contenu de ce dernier.


'use strict';

// Importsconst express = require('express');
const bodyParser = require('body-parser');
const fs = require('fs');
const path = require('path');
const https = require('https');
const util = require('util');

module.exports = function (middlewares) {
    // Define the REST server    let app = express();
    app.use(bodyParser.urlencoded({ 'extended': true }));
    app.use(bodyParser.json());

    app.use('/', express.static(path.resolve(path.join(__dirname, '../www'))));

    if (util.isFunction(middlewares)) {
        middlewares(app);
    }

    app.use('/api', function (req, resp, next) {
        console.log(`Is authorized: ${req.socket.authorized}`);
        console.log(`Peer certificate: ${JSON.stringify(req.socket.getPeerCertificate(), null, '\t')}`);
        next();
    });

    let router = express.Router();
    router.get('/', function(req, res) {
        res.json({ 'message': 'hooray! welcome to our api!' });
    });

    app.use('/api', router);

    return app;
};


La page Web

Egalement, cette dernière est toute bête. A noter que nous faisons notre appel Ajax en utilisant l'API Fetch d'HTML5.


<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Sample site</title>
    </head>

    <body>
        <h1>A sample site</h1>
        <hr />
        <button type="button">Load some JSON</button>
        <pre></pre>

        <script type="text/javascript">
            var preElement = document.querySelector('pre');

            document
                    .querySelector('button')
                    .addEventListener('click', function (event) {
                        var self = this;
                        this.disabled = true;
                        preElement.innerText = '';

                        fetch('/api', { 'method': 'get', 'headers': { 'X-Requested-With': 'fetch' } })
                            .then(function (response) {
                                return response.json();
                            })
                            .then(function (json) {
                                preElement.innerText = JSON.stringify(
                                   json,
                                   null,
                                   '\t'
                                );
                                self.disabled = false;
                            })
                            .catch(function () {
                                alert('An error occured');
                                self.disabled = false;
                            });
                    });
        </script>
    </body>
</html>



Les clients NodeJs

Les clients utiliseront le module request, qui est simple d'utilisation tout en restant assez proche du module NodeJs HTTP / HTTPS.

Nous ferons nos appels de la façon suivante:

request

    .get(requestOptions)
    .on('response', function(response) {
        if (response.statusCode >= 200 && response.statusCode < 300) {

            response.on('data', function(data) {
                console.log(data.toString());
            });
        } else {
            console.error(`Error [${response.statusCode}]: ${response.statusMessage}`);
        }
    })
    .on('error', function(err) {
        console.error(err);
    });


Pour les 5 clients NodeJs que nous allons utiliser, nous trouverons les configurations suivantes.

Un client NodeJs sans certificats SSL

static generateBasicRequestOptions(strictSSL) {
    return {
        'url': `https://${constants.API_URL}`,
        'strictSSL': strictSSL
    };
};

Un client NodeJs avec un certificat SSL client non fiable

static generateTrustedClientRequestOptions(strictSSL) {
    return Object.assign(
        {
            'url': `https://${constants.API_URL}`,
            'strictSSL': strictSSL
        },
        sslClientCertificates(path.resolve(path.join(__dirname, '../resources/trusted')))
    );
};

Un client NodeJs avec un certificat SSL server non fiable

static generateUntrustedServerRequestOptions(strictSSL) {
    return Object.assign(
        {
            'url': `https://${constants.API_URL}`,
            'strictSSL': strictSSL
        },
        sslServerCertificates(path.resolve(path.join(__dirname, '../resources/untrusted')))
    );
};

Un client NodeJs avec un certificat SSL client fiable

static generateTrustedClientRequestOptions(strictSSL) {
    return Object.assign(
        {
            'url': `https://${constants.API_URL}`,
            'strictSSL': strictSSL
        },
        sslClientCertificates(path.resolve(path.join(__dirname, '../resources/trusted')))
    );
};

Un client NodeJs avec un certificat SSL serveur fiable

static generateTrustedServerRequestOptions(strictSSL) {


    return Object.assign(
        {
            'url': `https://${constants.API_URL}`,
            'strictSSL': strictSSL
        },
        sslServerCertificates(path.resolve(path.join(__dirname, '../resources/trusted')))
    );
};


Nos différents tests

Cas 1) Un serveur HTTPS avec un certificat auto-signé

Tout d'abord, l'implémentation:

'use strict';

// Importsconst https = require('https');
const path = require('path');

const restApp = require('../rest-app');
const constants = require('../constants');
const sslCertificates = require('../certificates');

// Define HTTPS serverlet httpsServer = https.createServer(
    Object.assign(
        {
            'requestCert': true,
            'rejectUnauthorized': false        },
        sslCertificates(path.resolve(path.join(__dirname, '../../resources/untrusted')))
    ),
    restApp()
);

httpsServer.listen(constants.DEFAULT_PORT);console.log(`Server run on https://localhost:${constants.DEFAULT_PORT}`);


Pour commencer, qu'avons-nous ? Nous avons un serveur sur lequel nous allons lui charger les fichiers de certificats SSL, en l'occurence:
  • Le "ca" pour le "certificat authority"
  • Le "cert" pour la clé publique
  • Le "key" pour la clé privée

En plus, nous avons deux options à notre disposition:
  • Le "requestCert" afin d'obtenir le certificat SSL lors de la requête HTTP
  • Le "rejectUnauthorized" a pour but de rejeté une requête HTTP si le certificat fourni n'est pas signé avec la même autorité de certification (autrement dit, avec le même CA)

Dans notre exemple, ce dernier paramètre n'est pas fourni.

Que constatons-nous ?

Cas
Résultat
Un client NodeJs sans certificats SSL – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs sans certificats SSL – strictSSL false
Côté serveur :
Is authorized: false
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL client non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs avec un certificat SSL client non fiable – strictSSL false
Côté serveur :
Is authorized: false
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL server non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs avec un certificat SSL server non fiable – strictSSL false
Côté serveur :
Is authorized: false
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL client fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs avec un certificat SSL client fiable – strictSSL false
Côté serveur :
Is authorized: false
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL false
Côté serveur :
Is authorized: false
Peer certificate: [object Object]

Côté client :
Le json récupéré
Une application Web
Nous accédons à notre page
Une requête Ajax dans une application Web
Côté serveur :
Is authorized: false
Peer certificate: {}

Côté client :
Le json récupéré


Au final, nous pouvons que du moment que l'option "strictSSL" est à false, nous pouvons interroger l'api REST sans aucun soucis. En revanche, nous ne pouvons pas accèder à la page Web.


Cas 2) Un serveur HTTPS avec un certificat auto-signé et "rejectUnauthorized" à true

L'implémentation est la même que le cas précédent, à ceux-ci prêt que nous spécifions la propriété "rejectUnauthorized" à true.

Voyons ce que cela donne:

Cas
Résultat
Un client NodeJs sans certificats SSL – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs sans certificats SSL – strictSSL false
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL client non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL client non fiable – strictSSL false
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL server non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL server non fiable – strictSSL false
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL client fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL client fiable – strictSSL false
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL false
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Une application Web
Côté serveur :
-

Côté client :
ERR_SSL_PROTOCOL_ERROR
Une requête Ajax dans une application Web
-

Sans grande surprise, nous voyons que nous ne pouvons plus rien faire, même en ayant l'option "strictSSL" à false.

Cas 3) Un serveur HTTPS avec un certificat auto-signé et  une gestion "à la main"

Le but ici est de revenir au cas 1, tout en faisant une gestion plus poussé du certificat. Ainsi, nous aurons l'implémentation suivante:


'use strict';

// Importsconst https = require('https');
const path = require('path');
const _ = require('lodash');

const restApp = require('../rest-app');
const constants = require('../constants');
const sslCertificates = require('../certificates');

// Define HTTPS serverlet app = restApp(function (app) {
    app.use(function (req, resp, next) {
        if (req.socket.authorized) {
            next();

        } else {
            let serverCertificate = httpsServer._sharedCreds.context.getCertificate();
            let peerCertificate = req.socket.getPeerCertificate();

            if (_.isEqual(serverCertificate, peerCertificate.raw)) {
                next();

            } else {
                resp
                    .status(403)
                    .send();
            }
        }
    });
});

let httpsServer = https.createServer(
    Object.assign(
        {
            'requestCert': true,
            'rejectUnauthorized': false // Pass it to true only in production mode with trusted SSL certificates        },
        sslCertificates(path.resolve(path.join(__dirname, '../../resources/untrusted')))
    ),
    app);

httpsServer.listen(constants.DEFAULT_PORT);
console.log(`Server run on https://localhost:${constants.DEFAULT_PORT}`);

Ici, le principe est de comparer le certificat associé au serveur avec celui fourni par la requête HTTP.  Pour cela nous allons ajouter un middleware au tout début de l'initialisation du serveur Express. Cela implique en revanche de mettre "rejectUnauthorized" à false. Cela va nous donner le tableau suivant:

Cas
Résultat
Un client NodeJs sans certificats SSL – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs sans certificats SSL – strictSSL false
Côté serveur :
-

Côté client :
Error [403]: Forbidden
Un client NodeJs avec un certificat SSL client non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs avec un certificat SSL client non fiable – strictSSL false
Côté serveur :
-

Côté client :
Error [403]: Forbidden
Un client NodeJs avec un certificat SSL server non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs avec un certificat SSL server non fiable – strictSSL false
Côté serveur :
Is authorized: false
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL client fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs avec un certificat SSL client fiable – strictSSL false
Côté serveur :
-

Côté client :
Error [403]: Forbidden
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate] code: 'DEPTH_ZERO_SELF_SIGNED_CERT' }
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL false
Côté serveur :
-

Côté client :
Error [403]: Forbidden
Une application Web
Nous accédons à notre page
Une requête Ajax dans une application Web
Nous avons une erreur 403

Ici, nous avons réussi à limiter l'accès à notre serveur. Ce qui est bien. En revanche, nous tombons sur trois problèmes:

  • Nous ne pouvons plus faire de requête Ajax
  • Nous utilisons pour les requêtes HTTP le même certificat que le serveur. Ce qui n'est pas une bonne chose
  • Nous devons écrire un peu plus de code "non fiable" (quid de la gestion de l'expiration du certificat SSL ?)
Ce dernier point est important, car il serait idéale de laisser plus de gestion côté NodeJs. C'est pourquoi nous allons réessayer d'utiliser l'option "rejectUnauthorized".


Cas 4) Un serveur HTTPS avec un certificat "sûr"

Ici, l'objectif est de réutiliser le cas 2 avec cette fois-ci utiliser un certificat qui soit plus sûr. Nous aurons alors comme résultat:

Cas
Résultat
Un client NodeJs sans certificats SSL – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: write EPROTO]
  code: 'EPROTO',
  errno: 'EPROTO',
  syscall: 'write',
  address: undefined }
Un client NodeJs sans certificats SSL – strictSSL false
Côté serveur :
-

Côté client :
{ [Error: write EPROTO]
  code: 'EPROTO',
  errno: 'EPROTO',
  syscall: 'write',
  address: undefined }
Un client NodeJs avec un certificat SSL client non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL client non fiable – strictSSL false
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL server non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL server non fiable – strictSSL false
Côté serveur :
-

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL client fiable – strictSSL true
Côté serveur :
Is authorized: true
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL client fiable – strictSSL false
Côté serveur :
Is authorized: true
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL true
Côté serveur :
Is authorized: true
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL false
Côté serveur :
Is authorized: true
Peer certificate: [object Object]

Côté client :
Le json récupéré
Une application Web
Côté serveur :
-

Côté client :
ERR_SSL_PROTOCOL_ERROR
Une requête Ajax dans une application Web
-

Avec cette étape, nous pouvons noter de nombreuses améliorations:
  • Nous ne faisons plus de gestion à la main
  • La connexion au serveur HTTPS doit présenter un certificat SSL compatible avec le même CA
    • Nous pouvons du coup utiliser un certificat SSL client généré à partir du même CA
  • Nous n'avons plus besoin de préciser l'option "strictSSL" au moment des requêtes HTTP
Le seul problème que nous avons se situe au niveau de la page Web que nous ne pouvons pas accéder.

L'approche naïve serait de proposer un serveur HTTPS pour les page Web et un autre pour l'api REST. Mais cela poserait le problème du cross-domain.

Le dernier cas que nous allons aborder va proposer une solution permettant de gérer nos deux besoins.


Cas 5) Un serveur HTTPS avec un certificat "sûr" et une renégociation

Le but ici va d'être de désactiver l'option "rejectUnauthorized". Mais en revanche, lorsque une requête HTTP sera faite sur l'api REST, nous allons:
  • Soit vérifier que nous sommes sur une requête Ajax et la laisser passer
  • Soit faire une renégociation
Le principe de ce dernier point est de revérifier la requête en modifiant les deux paramètres "requestCert" et "rejectUnauthorized". Ce qui nous donne l'implémentation suivante:


'use strict';

// Importsconst https = require('https');
const path = require('path');

const restApp = require('../rest-app');
const constants = require('../constants');
const sslCertificates = require('../certificates');

// Constantsconst HEADER_X_REQUESTED_WITH = 'x-requested-with';
const HEADER_CONNECTION = 'connection';
const HEADER_VALUE_XML_HTTP_REQUEST = 'XMLHttpRequest';
const HEADER_VALUE_FETCH = 'fetch';
const HEADER_VALUE_KEEP_ALIVE = 'keep-alive';

// Define HTTPS serverlet app = restApp(function (app) {
    app.use('/api', function (req, resp, next) {
        if (req.xhr || req.headers[HEADER_X_REQUESTED_WITH] === HEADER_VALUE_XML_HTTP_REQUEST  || req.headers[HEADER_X_REQUESTED_WITH] === HEADER_VALUE_FETCH || req.headers[HEADER_CONNECTION] === HEADER_VALUE_KEEP_ALIVE) {
            // Ajax & Fetch calls            next();

        } else {
            // See https://nodejs.org/api/tls.html#tls_tlssocket_renegotiate_options_callback            req.socket.renegotiate({ 'requestCert': true, 'rejectUnauthorized': true }, function (err) {
                if (err) {
                    resp
                        .status(403)
                        .end();

                } else {
                    next();
                }
            });
        }
    });
});

let httpsServer = https.createServer(
    Object.assign(
        {
            'requestCert': true,
            'rejectUnauthorized': false        },
        sslCertificates(path.resolve(path.join(__dirname, '../../resources/trusted')))
    ),
    app);

httpsServer.listen(constants.DEFAULT_PORT);
console.log(`Server run on https://localhost:${constants.DEFAULT_PORT}`);

Et nous aurons alors les résultats suivants:

Cas
Résultat
Un client NodeJs sans certificats SSL – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate in certificate chain] code: 'SELF_SIGNED_CERT_IN_CHAIN' }
Un client NodeJs sans certificats SSL – strictSSL false
Côté serveur :
Is authorized: false
Peer certificate: null

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL client non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate in certificate chain] code: 'SELF_SIGNED_CERT_IN_CHAIN' }
Un client NodeJs avec un certificat SSL client non fiable – strictSSL false
Côté serveur :
Is authorized: false
Peer certificate: null

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL server non fiable – strictSSL true
Côté serveur :
-

Côté client :
{ [Error: self signed certificate in certificate chain] code: 'SELF_SIGNED_CERT_IN_CHAIN' }
Un client NodeJs avec un certificat SSL server non fiable – strictSSL false
Côté serveur :
Is authorized: false
Peer certificate: null

Côté client :
{ [Error: socket hang up] code: 'ECONNRESET' }
Un client NodeJs avec un certificat SSL client fiable – strictSSL true
Côté serveur :
Is authorized: true
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL client fiable – strictSSL false
Côté serveur :
Is authorized: true
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL true
Côté serveur :
Is authorized: true
Peer certificate: [object Object]

Côté client :
Le json récupéré
Un client NodeJs avec un certificat SSL serveur fiable – strictSSL false
Côté serveur :
Is authorized: true
Peer certificate: [object Object]

Côté client :
Le json récupéré
Une application Web
Nous accédons à notre page
Une requête Ajax dans une application Web
Côté serveur :
Is authorized: false
Peer certificate: {}

Côté client :
Le json récupéré



Et voilà ! Nous avons un serveur HTTPS qui est sûr, qui n'autorise les connexions extérieures uniquement si le certificat SSL présenté est valide, tout en autorisant nos propres requêtes Ajax. Et cela en relayant le maximum le traitement à NodeJS !

Commentaires

  1. PRODUCTIVIX Sarl28 février 2021 à 09:08

    Bonjour, intéressant votre étude - est-ce possible d'avoir les fichiers en zip du projet SVP dans chaque cas ou seulement le dernier si possible ? Merci

    RépondreSupprimer

Enregistrer un commentaire

Posts les plus consultés de ce blog

ISO: liens & outils utiles

Image
Voici quelques normes ISO à connaître et que vous aurez à faire face dans vos développements. Et quelques liens / outils permettant de s'assurer que nous faisons correctement leurs intégrations Code Pays https://countrycode.org/ est super site qui permet de lister les pays du monde avec leur country code (en mode number et iso): Et par pays, nous pouvons avoir des informations supplémentaires, comme le format téléphone, la position géographique, la time zone, la monnaie, etc: Ce site du coup regroupe les country code: En ISO 3166 name (où un nom est attribué à un pays) En ISO 3166 numeric (où un chiffre numérique est attribué à un pays) En ISO 3166-1 alpha-2 (code en 2 alpha majuscule) En ISO 3166-1 alpha-3 (code en 3 alpha majuscule) Ainsi que les langues. Tout cela est d'ailleurs regroupés dans ce fichier téléchargeable . Code langue / locale Là, nous tombons dans un des plus grands soucis d'un développeur: co...
Lire la suite

Créer sa commande slack en quelques minutes

Image
Le but de cet article est de vous montrer que très simplement, nous pouvons créer une commande personnalisée pour Slack. Ici, nous allons afficher des chats :)" Tout d'abord, nous allons nous créer des comptes sur: Slack:  https://slack.com Heroku:  http://www.heroku.com/ qui permettra d'héberger notre service REST pour Slack Gitlab: https://gitlab.com  qui permet évidemment d'héberger notre code, mais qui pourra de manière automatiser déployer notre application sur Heroku à chaque commit (et cela, même en mode "gratuit") Concentrons-nous tout d'abord sur Heroku et Gitlab. Créons un compte Heroku. Une fois cela fait, aller dans votre compte :. Vous verrez alors une section nommée "API key": Cliquez sur "Reveal" pour voir la valeur et conservez la bien en mémoire. Ensuite, sur en retournant sur votre dashboard d'applications Heroku , cliquez sur "New" et créez une nouvelle application. Dans...
Lire la suite