Table des matières

NodeJS

Installation

Mac OS X

  1. Pour une installation sur Mac OS X, tout simplement télécharger l'installateur indépendant sur la page de téléchargement.
  2. Ouvrir le fichier .pkg téléchargé et suivre les étapes.

Linux

Installer la LTS

Voir Installing Node.js via package manager

Au moment d'écrire ceci, la LTS de Node la plus récente était 4.6.0. Pour installer sur Ubuntu:

$ curl -sL https://deb.nodesource.com/setup_4.x | sudo -E bash -
$ sudo apt-get install -y nodejs

Même principe pour Node 8.x :

$ curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
$ sudo apt-get install -y nodejs

NPM

Voir la page sur npm.

Simple serveur HTTP

On peut utiliser Connect et ServeStatic avec NodeJS.

  1. Installer connect et serve-static avec NPM
    $ npm install connect serve-static
  2. Créer le fichier server.js et y mettre :
    var connect = require('connect');
    var serveStatic = require('serve-static');
    connect().use(serveStatic(__dirname)).listen(8080);
  3. Exécuter le code avec NodeJS
    $ node server.js
  4. Aller au fichier voulu sur http://localhost:8080/.

On peut créer un serveur utilisant HTTP2.

Source : Using node.js as a simple web server

Sécurité avec Node, Express et AngularJS

Sécurité de base

$ npm audit

Protéger les données de l'extraction

XSS

La façon traditionnelle de se procurer des informations et d'utiliser le XSS. Par exemple, dans une boîte de saisie, si on entre <script>alert(sessionStorage.userAuthToken);</script> on pourrait afficher de l'information sur le token de l'utilisateur.

Prévention

Content Security Policy

Dans l'entête HTTP de la réponse que le client reçoit, on peut ajouter une entête content-security-policy.

Un exemple de valeur est :

content-security-policy: default-src 'self'; style-src 'self'; img-src 'self' http://localhost:8080;

Supporté par les navigateurs récents, pas IE8, IE9 et IE11 supporte X-Content-Security-Policy. Voir Can I Use - Content Security Policy 1.0.

Pour plus de détails, voir Content Security Policy, Your Future Best Friend.

XSS Filters

Le Secure XSS Filters est un module qui peut être utilisé dans node pour nettoyer les entrées utilisateur.

$ npm install xss-filters --save

Lusca

Lusca est un middleware de sécurité pour gérer les Content Security Policy (CSP).

$ npm install lusca --save
const lusca = require('lusca');
 
app.use(lusca.csp({
    policy: {
        'default-src': '\'self\'',
        'style-src': '\'self\'',
        'img-src': '\'self\'',
    }
}));

Puisqu'on parle de sécurité aussi avec AngularJS, on doit lui dire qu'on utilise les CSP:

<!DOCTYPE html>
<html ng-app="app" ng-csp>
    <!-- reste du fichier ignoré. -->

jQuery charge des images avec data:image/png;base64, donc dans policy on peut le permettre et plutôt mettre:

        'img-src': '\'self\' data:',

Encrypter le trafic

Pour encrypter le trafic entre le serveur Node et le client, il faut utiliser le HTTPS.

Pour se faire, il faut créer un certificat, soit par une autorité pour la production, soit un certificat auto-signé pour le développement.

Ensuite, il faut utiliser les modules https et fs de node.

const https = require('https');
const fs = require('fs');
 
const options = {
    key: fs.readFileSync('./key.pem'),
    cert: fs.readFileSync('./cert.pem')
};

Ensuite, au lieu du traditionnel app.listen(), on utilise https.createServer(options, app).listen().

https.createServer(options, app).listen(port, function() {
    console.log('Express server listening on port ' + port);
});

Autre méthode

XSS occurs when the attacker injects executable JavaScript code into the HTML response.

To mitigate these attacks, you have to set flags on the set-cookie HTTP header:

HttpOnly - this attribute is used to help prevent attacks such as cross-site scripting since it does not allow the cookie to be accessed via JavaScript. secure - this attribute tells the browser to only send the cookie if the request is being sent over HTTPS.

Autres sujets

Ressources

Debugging

Debugging avec NodeJS

$ node --inspect hello.js

Ceci permet d'arrêter l'exécution dès la première ligne:

$ node --inspect-brk hello.js

CLI debugger:

$ node inspect hello.js

Dans Chrome : about:inspectOpen dedicated DevTools for Node.

Fonctionne aussi avec chrome://inspect.

Outils qui lancent Devtools:

Autres outils

CommonJS

exports

Pour rendre des fonctions ou des variables publiques, en dehors du fichier .js actuel, on utilise exports.

logger.js
exports.info = function (msg) {
  console.log(msg);
}
 
exports.error = function (msg) {
  console.error(msg);
}
app.js
var logger = require('./logger');
 
logger.info('hello monde!');

Un autre exemple avec une instantiation d'objet :

Point.js
function Point (x, y) {
  this.x = x;
  this.y = y;
}
 
Point.prototype.print = function () {
  console.log(this.x + ', ' + this.y);
}
 
module.exports = Point;  // Ce qui sera retourné est le constructeur.
app.js
var Point = require('./Point');
var pt = new Point(48, 29);
pt.print();

Express

Express est le framework de facto de NodeJS. D'autres frameworks existent : hapi, restify, geddy, koa, etc. Express permet d'utiliser des middlewares qui sont des modules qui traitent les données de requêtes / réponses.

Caching avec Redis

Gestion des versions

Gestion des erreurs

process.stdin.resume();//so the program will not close instantly

function exitHandler(options, err) {
    if (options.cleanup) console.log('clean');
    if (err) console.log(err.stack);
    if (options.exit) process.exit();
}

//do something when app is closing
process.on('exit', exitHandler.bind(null,{cleanup:true}));

//catches ctrl+c event
process.on('SIGINT', exitHandler.bind(null, {exit:true}));

// catches "kill pid" (for example: nodemon restart)
process.on('SIGUSR1', exitHandler.bind(null, {exit:true}));
process.on('SIGUSR2', exitHandler.bind(null, {exit:true}));

//catches uncaught exceptions
process.on('uncaughtException', exitHandler.bind(null, {exit:true}));

Avancé

Callbacks

function hideString(str, done) {
  done(replace

Microservices avec Node

Ceci n'est pas une page qui explique le concept de microservice, mais plutôt une implémentation de ce pattern architectural avec Node.

Il y a le livre Developing Microservices with Node.js qui existe en ce sens.

Utilisation de Seneca

Seneca est un package npm qui permet de facilement mettre en oeuvre des microservices.

Exemple de base pris du livre:

var seneca = require('seneca')();
 
seneca.add({component: 'greeter'},(msg, respond) => {
    respond(null, {message: 'Hello ' + msg.name});
});
 
seneca.act({component: 'greeter', name: 'David'},(error, response) => {
    if(error) return console.log(error);
 
    console.log(response.message);
});

Modules

Outils

Command-Line App

Rendre global

Dans le fichier package.json, ajouter une section bin :

  "bin": {
    "mycli": "index.js"
  },

Là où est mycli, c'est le nom de la commande que l'on veut.

Dans le fichier index.js, ajouter à l'entête :

#!/usr/bin/env node

À la racine du projet, là où se trouve le fichier package.json, faire :

$ npm link

En tapant la commande, ça devrait exécuter l'application:

$ mycli

Ressources

Tests

Resources