Aller au contenu
Encyclopédie informatique Édition 2026

WebAssembly

Partie 2 sur 3

Niveau de lecture :

3Comment ça marche

3.1Du code source au navigateur

Le programme est compilé chez le développeur en un module, un fichier d’extension .wasm. Le navigateur le télécharge, le valide, c’est-à-dire vérifie qu’il respecte les règles du format, en particulier les types de données, puis le compile en code machine pour le processeur de l’ordinateur, souvent pendant même le téléchargement. Le code s’exécute ensuite dans un bac à sable, et communique avec la page par l’intermédiaire de JavaScript (figure 1).

CHEZ LE DÉVELOPPEUR C, C++ Rust Go, C#, Kotlin… compilateur vers WebAssembly module calcul.wasm binaire compact DANS LE NAVIGATEUR 1. validation du module 2. compilation en code machine 3. exécution dans un bac à sable JavaScript, la « colle » page, réseau, API Web Le même module tourne sur tous les navigateurs et tous les processeurs.
Figure 1. Compilé une fois par le développeur, le module est validé, compilé en code machine et exécuté en sécurité par chaque navigateur.

3.2Une machine à pile

WebAssembly est une machine à pile : ses instructions prennent leurs opérandes au sommet d’une pile et y déposent leur résultat (figure 2). Il ne connaît au départ que quatre types de valeurs : entiers de 32 et 64 bits, nombres à virgule de 32 et 64 bits, auxquels se sont ajoutés des vecteurs pour le calcul parallèle et des références. Le format binaire a un équivalent textuel, lisible par un humain, appelé WAT. Voici une fonction qui additionne deux entiers :

(module
  (func $ajouter (export "ajouter")
        (param $a i32) (param $b i32) (result i32)
    local.get $a      ;; empile a
    local.get $b      ;; empile b
    i32.add))         ;; dépile les deux, empile leur somme
EXÉCUTION DE ajouter(2, 3) SUR LA PILE local.get $a 2 empile a local.get $b 2 3 empile b i32.add 5 dépile 2 et 3, empile la somme fin : résultat 5 la valeur restante est renvoyée Chaque instruction prend ses opérandes au sommet de la pile et y dépose son résultat.
Figure 2. Une machine à pile : simple à valider, simple à traduire en code machine.

Pourquoi une pile, alors que les vrais processeurs utilisent des registres ? Parce que ce format est compact, facile à valider et indépendant du nombre de registres de chaque processeur : c’est le compilateur du navigateur qui répartit ensuite les valeurs dans les registres du processeur réel. Le flux de contrôle, lui, est structuré : pas de saut vers une adresse arbitraire, seulement des blocs, des boucles et des branchements vers des étiquettes bien définies, ce qui rend la validation rapide et le code plus sûr.

3.3Dialoguer avec JavaScript

Un module déclare ce qu’il exporte, des fonctions ou de la mémoire que d’autres peuvent utiliser, et ce qu’il importe, des fonctions dont il a besoin et que l’hôte doit lui fournir. Du côté de la page, quelques lignes de JavaScript suffisent pour charger le module et appeler ses fonctions :

const { instance } = await WebAssembly.instantiateStreaming(
  fetch("calcul.wasm")             // téléchargé et compilé en même temps
);
console.log(instance.exports.ajouter(2, 3));   // affiche 5

WebAssembly n’a pas d’accès direct à la page, au réseau ou au stockage : tout passe par des fonctions JavaScript importées. Échanger des nombres est quasi gratuit ; échanger des textes ou des objets complexes demande de les copier dans la mémoire du module et de les convertir, ce qui a un coût. Des outils, comme Emscripten pour C et C++ ou wasm-bindgen pour Rust, génèrent automatiquement ce code de liaison. La règle pratique : confier à WebAssembly de gros calculs, appelés peu souvent, plutôt que de multiplier les petits échanges.

3.4Un exemple en C

Voici une fonction C qui additionne les éléments d’un tableau d’entiers :

/* somme.c */
int somme(const int *t, int n) {
    int s = 0;
    for (int i = 0; i < n; i++)
        s += t[i];
    return s;
}

Le compilateur Clang, qui sait produire du WebAssembly, la transforme en module, sans bibliothèque standard ni fonction principale, en exportant la fonction somme :

clang --target=wasm32 -O2 -nostdlib -Wl,--no-entry -Wl,--export=somme \
      -o somme.wasm somme.c

Le module obtenu ne pèse que quelques centaines d’octets. Un point mérite attention : en C, t est un pointeur, une adresse en mémoire. En WebAssembly, cette adresse devient un simple indice dans la mémoire linéaire du module. Pour appeler la fonction depuis JavaScript, il faut donc d’abord écrire le tableau dans la mémoire du module, à un emplacement réservé, puis passer à somme cet emplacement et le nombre d’éléments. C’est exactement le travail que les outils de liaison automatisent pour les cas plus complexes : textes, structures, objets.

3.5Quels langages ?

Presque tous les langages courants peuvent aujourd’hui produire du WebAssembly, avec plus ou moins de maturité :

  • C et C++, avec Emscripten, la chaîne historique, qui fournit aussi une grande partie des bibliothèques habituelles, y compris pour le graphisme et le son (voir le langage C) ;
  • Rust, très apprécié pour WebAssembly : pas de ramasse-miettes à embarquer, des modules compacts, et des outils de liaison avec JavaScript particulièrement soignés ;
  • Go, directement ou avec TinyGo, une version allégée qui produit des modules plus petits ;
  • C#, avec Blazor de Microsoft, qui permet d’écrire des applications Web entières en C# ;
  • Kotlin, Dart et Java, qui profitent du ramasse-miettes intégré de WebAssembly 3.0 : le moteur de calcul de Google Sheets a ainsi été porté de Java vers WebAssembly, et s’est révélé environ deux fois plus rapide que sa version JavaScript ;
  • AssemblyScript, un langage proche de TypeScript conçu pour WebAssembly, pratique pour les développeurs Web ;
  • les langages interprétés, comme Python ou Ruby, dont on compile l’interpréteur lui-même en WebAssembly : le programme fonctionne, mais le module pèse plusieurs mégaoctets.

3.6Le format binaire

Un fichier .wasm commence par quatre octets magiques, un octet nul suivi des lettres asm, puis le numéro de version du format. Viennent ensuite des sections, dans un ordre fixé : les types des fonctions, les imports, la liste des fonctions, les tables, la mémoire, les variables globales, les exports, la fonction de démarrage éventuelle, puis le code de chaque fonction et les données initiales de la mémoire. Les nombres sont codés avec un nombre variable d’octets, selon leur taille, ce qui rend le format très compact.

Cet ordre n’est pas un hasard : il permet au navigateur de valider le module en une seule lecture, et de commencer à compiler chaque fonction dès qu’elle est arrivée, pendant que la suite du fichier se télécharge. Les navigateurs utilisent souvent deux compilateurs : un premier, très rapide, produit du code correct en quelques millisecondes pour que le programme démarre tout de suite ; un second, optimisant, recompile en arrière-plan les fonctions les plus utilisées. On obtient ainsi à la fois un démarrage rapide et une bonne vitesse de croisière. Contrairement à JavaScript, dont le compilateur doit deviner les types des variables et peut devoir revenir en arrière quand il s’est trompé, WebAssembly déclare tous ses types : ses performances sont plus prévisibles.

3.7Quelle vitesse ?

« Proche du natif » ne veut pas dire « égal au natif ». Une étude de 2019 a mesuré que des programmes de calcul compilés en WebAssembly étaient en moyenne environ 1,5 fois plus lents que leur version native, avec de grandes variations selon les programmes et les navigateurs. Plusieurs raisons à cela : les vérifications d’accès à la mémoire, un code machine moins optimisé que celui des meilleurs compilateurs natifs, et l’absence de certaines instructions spécialisées des processeurs. Les extensions ajoutées depuis, comme les instructions de calcul parallèle, dites SIMD (Single Instruction, Multiple Data, une instruction qui traite plusieurs données à la fois), réduisent l’écart pour le traitement d’images, d’audio ou les calculs d’IA.

WebAssembly peut aussi utiliser plusieurs fils d’exécution en parallèle, grâce à une mémoire partagée entre eux. Cette possibilité a été temporairement désactivée en 2018 après la découverte de Spectre, une famille d’attaques qui exploite le fonctionnement des processeurs pour lire des données interdites en mesurant très finement des durées. Elle est revenue avec une contrainte : une page ne peut utiliser la mémoire partagée que si elle se déclare isolée des autres sites, par des en-têtes envoyés par son serveur.

Pour s’exercer

Exercice 1 : exécuter à la main

Que calcule cette fonction ? Déroulez son exécution sur la pile pour x = 4.

(func $f (param $x i32) (result i32)
  local.get $x
  local.get $x
  i32.mul
  i32.const 1
  i32.add)
Voir la réponse

Avec x = 4 : local.get $x empile 4 ; la pile contient [4]. Le second local.get $x empile 4 : [4, 4]. i32.mul dépile les deux et empile leur produit : [16]. i32.const 1 empile 1 : [16, 1]. i32.add dépile et empile la somme : [17]. La fonction renvoie 17. Elle calcule x² + 1.

Exercice 2 : WebAssembly ou JavaScript ?

Pour chaque projet, WebAssembly est-il pertinent ? (a) Un formulaire d’inscription avec vérification des champs ; (b) un éditeur de photos qui applique des filtres à des images de 20 millions de pixels ; (c) le portage dans le navigateur d’un logiciel de simulation écrit en C++ depuis quinze ans ; (d) un menu déroulant animé.

Voir la réponse

(a) et (d) : non, JavaScript, HTML et CSS suffisent largement, et il s’agit surtout de manipuler la page. (b) Oui : appliquer un filtre à 20 millions de pixels est un calcul intensif, sur des données qui restent dans la mémoire du module, idéal pour WebAssembly, éventuellement avec ses instructions de calcul parallèle. (c) Oui : c’est l’un des usages phares, qui évite de réécrire des centaines de milliers de lignes ; Emscripten compile le code C++ et fournit l’essentiel des bibliothèques nécessaires.

Exercice 3 : le coût des échanges

Une fonction WebAssembly calcule en 1 microseconde ce que JavaScript calcule en 5. Mais chaque appel depuis JavaScript demande de copier les données dans la mémoire du module, ce qui prend 6 microsecondes. Faut-il l’utiliser pour un million d’appels indépendants ? Comment faire mieux ?

Voir la réponse

Par appel, WebAssembly coûte 1 + 6 = 7 microsecondes, contre 5 pour JavaScript : il est plus lent, et sur un million d’appels, on perd 2 secondes. Mieux vaut regrouper : copier toutes les données en une seule fois dans la mémoire du module, faire le million de calculs à l’intérieur, puis récupérer les résultats en une fois. Le coût de copie devient alors négligeable par rapport au calcul. C’est la règle générale : peu d’échanges, beaucoup de calcul de chaque côté.

Exercice 4 : la mémoire linéaire

Un programme C compilé en WebAssembly copie un texte saisi par l’utilisateur dans un tableau de 16 octets, sans vérifier sa longueur. L’utilisateur saisit 40 caractères. Que se passe-t-il ? Le navigateur est-il en danger ?

Voir la réponse

Les 24 octets en trop débordent du tableau et écrasent les données voisines dans la mémoire linéaire du module : d’autres variables, voire des informations qui influencent la suite du programme. C’est un dépassement de tampon classique (voir le dépassement de tampon). Le navigateur et le système ne sont pas en danger : les écritures ne peuvent pas sortir de la mémoire linéaire. Mais le programme peut se comporter de façon erronée, voire être manipulé, par exemple pour appeler une autre fonction ou transmettre des données falsifiées à la page. La correction se fait dans le code source : vérifier les longueurs, ou utiliser un langage sûr pour la mémoire, comme Rust.

Exercice 5 : accorder des droits avec WASI

Un outil de conversion d’images, compilé en WebAssembly avec WASI, doit lire des fichiers dans le dossier entree et écrire dans le dossier sortie. Quels accès lui accorder ? Que se passe-t-il s’il tente de lire le dossier personnel de l’utilisateur ?

Voir la réponse

On lui accorde seulement l’accès en lecture au dossier entree et en écriture au dossier sortie, et aucun accès réseau : un outil de conversion n’en a pas besoin. S’il tente d’ouvrir un fichier ailleurs, l’opération échoue, car ce dossier n’existe tout simplement pas pour lui. Même si l’outil était piégé, ou si une bibliothèque qu’il utilise était compromise, il ne pourrait ni lire les documents de l’utilisateur ni envoyer de données sur Internet. C’est l’application du principe de moindre privilège.

Exercice 6 : la taille de la mémoire

La mémoire linéaire de WebAssembly se compte en pages de 64 kibioctets, soit 65 536 octets. Un module déclare une mémoire initiale de 256 pages. Combien d’octets cela représente-t-il ? Dans la version d’origine, les adresses sont des entiers de 32 bits : quelle est la taille maximale de la mémoire ?

Voir la réponse

256 × 65 536 = 16 777 216 octets, soit 16 mébioctets. Avec des adresses de 32 bits, on peut désigner 232 octets, soit 4 gibioctets, c’est-à-dire 65 536 pages. Cette limite gênait les applications les plus gourmandes, comme les logiciels de conception ou certains modèles d’IA : WebAssembly 3.0 autorise des adresses de 64 bits, et donc des mémoires bien plus grandes, au prix de vérifications d’accès un peu plus coûteuses.

Exercice 7 : conteneur ou module ?

Un service reçoit des requêtes très irrégulières : parfois aucune pendant des heures, parfois des milliers en une minute. Chaque requête demande 5 millisecondes de calcul. Démarrer un conteneur prend environ 500 millisecondes ; instancier un module WebAssembly, environ 1 milliseconde. Quel est l’intérêt de WebAssembly ici ?

Voir la réponse

Pour ne pas payer un serveur qui attend pendant des heures, on veut démarrer le code seulement quand une requête arrive. Avec un conteneur, la première requête attend 500 ms de démarrage pour 5 ms de calcul, soit 100 fois plus ; il faut donc garder des conteneurs allumés en permanence, ce qui coûte. Avec un module WebAssembly, le démarrage ne coûte que 1 ms : on peut créer une instance par requête, isolée des autres, et n’en garder aucune en attente. C’est ce qui rend WebAssembly attractif pour les fonctions à la demande et l’informatique en périphérie de réseau. Le conteneur reste préférable pour des applications complètes, qui dépendent d’un système d’exploitation entier.

Exercice 8 : un processeur qui chauffe

En visitant un site de vidéos en streaming, un utilisateur constate que son ventilateur s’emballe et que son ordinateur ralentit, même quand la vidéo est en pause. L’onglet consomme 100 % d’un processeur. Que peut-il se passer ? Que faire ?

Voir la réponse

Le site, ou une publicité qu’il affiche, exécute peut-être un script de minage de cryptomonnaie, souvent écrit en WebAssembly pour sa rapidité, qui utilise le processeur du visiteur à son insu (coin cyber). Il faut fermer l’onglet, vérifier dans le gestionnaire de tâches du navigateur quel onglet consomme le processeur, et utiliser un bloqueur de contenus qui filtre les scripts de minage connus. Les navigateurs modernes en bloquent déjà une partie. Pour le responsable d’un site, c’est un signal possible de compromission ou d’une régie publicitaire peu scrupuleuse.

4Le bac à sable

La sécurité est au cœur de la conception de WebAssembly. Un module en cours d’exécution, appelé instance, est enfermé dans un bac à sable (figure 3) :

  • il dispose d’une mémoire linéaire, un simple tableau d’octets, et chaque lecture ou écriture est vérifiée : il est impossible de lire ou d’écrire en dehors, donc d’atteindre la mémoire du navigateur ou d’un autre onglet ;
  • son code est séparé de ses données : il ne peut ni être lu ni modifié par le programme lui-même, ce qui empêche d’injecter du code ;
  • les appels de fonctions indirects passent par une table, et leur type est vérifié à chaque appel ;
  • il n’a aucun accès au système, aux fichiers ou au réseau, sauf à travers les fonctions que l’hôte lui fournit explicitement, ses imports.
BAC À SABLE : UNE INSTANCE DE MODULE code compilé, non lisible ni modifiable table de fonctions appels indirects contrôlés mémoire linéaire : un tableau d’octets 0 N chaque accès est vérifié : impossible de lire ou d’écrire hors du tableau mais à l’intérieur, un débordement peut écraser d’autres données imports seules portes de sortie uniquement ce que l’hôte fournit l’hôte navigateur ou environnement serveur : décide de ce qu’il donne au module hors d’atteinte directe fichiers réseau autres onglets système
Figure 3. Un module WebAssembly ne voit que sa propre mémoire et ce que l’hôte lui confie.

Ce modèle, fondé sur les capacités, où un programme ne peut faire que ce pour quoi on lui a donné un moyen explicite, est plus strict que celui des programmes ordinaires, qui héritent de tous les droits de l’utilisateur. Il a toutefois une limite importante : il protège le système contre le module, pas le module contre lui-même. Un programme écrit en C, compilé en WebAssembly, garde ses éventuels débordements de tampon, qui peuvent corrompre ses propres données à l’intérieur de la mémoire linéaire (coin cyber).