Article

Exécuter du JavaScript généré par un agent dans une JVM

QuickJS et WebAssembly permettent d’exécuter du JavaScript dans une JVM avec des accès limités. Les fonctions exposées et les quotas restent à contrôler.

Un agent écrit un script pour lire des données et préparer un rapport. Le harnais, le programme qui fait travailler l’agent et exécute ses outils, doit lancer ce script sur le poste utilisateur sans lui donner librement les fichiers, les secrets ou toutes les destinations réseau. Comment exécuter ce code dans une application Java sans lui ouvrir l’application entière ? Pour un client écrit en Java, QuickJS compilé en WebAssembly illustre une façon de séparer le calcul des accès que l’application autorise : le script calcule, et ne touche à l’extérieur qu’à travers les fonctions que le code Java lui fournit.

Viennent d’abord ce qu’il faut isoler et les deux pièces de la solution, puis une recette minimale, exécutée, avec ce que ses cinq essais établissent et ce qu’ils laissent ouvert. Les deux sections suivantes décrivent des protections que la recette ne réalise pas : la sortie réseau et les limites de ressources. La dernière dit ce que cette isolation ne couvre pas.

Choisir ce qui doit être isolé avant de choisir le moteur

Un agent écrit du code quand il doit enchaîner des lectures, des filtres et des calculs ; l’article Outiller un agent IA : quand lui faire écrire du code explique ce choix. Ce code est généré : il peut boucler, allouer trop de mémoire ou tenter un appel inattendu. Le dispositif qui l’exécute doit limiter ces comportements et permettre d’arrêter l’exécution. Il doit aussi empêcher un script d’utiliser les identifiants ou les données d’un autre utilisateur.

Un processus ou un conteneur séparé apporte une frontière supplémentaire, avec un coût de démarrage et d’exploitation. Pour des scripts courts appelés fréquemment, une exécution dans la JVM peut être intéressante. Elle reste dans le même processus que l’application, ce qui limite l’isolation obtenue : la fin de l’article revient sur cette limite.

QuickJS exécute le langage, WebAssembly limite ses accès

QuickJS est un moteur JavaScript petit et conçu pour être embarqué. Il interprète le code du script. La famille QuickJS comprend aussi quickjs-ng, un fork du projet de Fabrice Bellard et Charlie Gordon ; le moteur réellement utilisé dépend de la version et de la chaîne d’intégration retenues.

WebAssembly, souvent abrégé Wasm, est un format de code exécutable dont l’environnement contrôle les accès à l’extérieur. Selon la documentation de sécurité de WebAssembly, un module s’exécute dans un bac à sable séparé de son hôte, et n’en sort qu’en passant par des interfaces prévues à cet effet. Il ne reçoit donc pas automatiquement le droit d’ouvrir un fichier ou une connexion réseau. Pour ces actions, l’application lui fournit des fonctions hôtes : des fonctions que le script peut appeler et dont l’implémentation appartient à l’application Java.

Reste à faire tourner QuickJS en WebAssembly dans une JVM. Javy, un projet de la Bytecode Alliance, exécute du JavaScript dans un module WebAssembly qui embarque un moteur JavaScript. La bibliothèque quickjs4j relie Java et QuickJS : selon sa documentation, elle compile QuickJS en WebAssembly, puis traduit ce module en bytecode Java avec le compilateur d’Endive, un runtime WebAssembly pour la JVM. Endive est un fork de Chicory, accueilli par la Bytecode Alliance en mai 2026, et ne demande ni JNI ni bibliothèque native. Toute la chaîne s’exécute donc dans la JVM.

Chaque pièce a donc sa responsabilité :

ComposantResponsabilité
Script généréCalculer avec les données et les fonctions autorisées.
QuickJS et WasmExécuter le script dans un environnement aux accès limités.
Client Java sur le posteConserver les secrets, contrôler les appels réseau et faire respecter les limites de ressources.

Une réalisation minimale exécutée

La recette suivante fixe une combinaison et distingue ce qu’elle a effectivement vérifié des protections encore à réaliser. L’exemple a été compilé avec quickjs4j et quickjs4j-annotations 0.1.0, le processeur d’annotations quickjs4j-processor 0.1.0 et Maven Compiler Plugin 3.14.1, avec une cible Java 17. Il a été exécuté sur Temurin 25.0.2, le 9 octobre 2026. La résolution Maven de quickjs4j 0.1.0 fournit le runtime Endive 1.0.0. Il s’agit d’un programme de démonstration autonome, pas de l’implémentation d’Arcate. Au 20 octobre 2026, Maven Central publie quickjs4j 0.1.1, depuis le 19 octobre, et Endive 1.1.0 : la recette n’a pas été rejouée avec ces versions.

Le projet quickjs4j fournit l’API Java et la génération des ponts par annotations. Le module QuickJS issu de la chaîne Wasm est embarqué dans la dépendance ; cet exemple ne recompile ni QuickJS ni Javy. Il faut placer les deux classes dans le même paquet demo et activer le processeur d’annotations Maven.

La fonction hôte ne lit qu’un document fictif D42. Aucun secret ni client HTTP n’entre dans le JavaScript :

package demo;
import io.roastedroot.quickjs4j.annotations.Builtins;
import io.roastedroot.quickjs4j.annotations.HostFunction;
@Builtins("rapport")
public class Api {
 @HostFunction("lire") public String lire(String id) {
  if (!"D42".equals(id)) throw new IllegalArgumentException("document hors mandat");
  return "{\"id\":\"D42\",\"total_centimes\":12000}";
 }
}

Le processeur génère Api_Builtins. Le lanceur limite la mémoire linéaire Wasm, la zone de mémoire que le module peut adresser, à 512 pages de 64 Kio, soit 32 Mio. Il fixe aussi deux délais distincts : 500 ms pour l’exécution du script, 5 s pour sa compilation.

package demo;
import io.roastedroot.quickjs4j.core.Engine;
import io.roastedroot.quickjs4j.core.Runner;
public class Main {
 public static void main(String[] args) {
  var engine=Engine.builder().withMemoryFactory(limits -> {
   if(limits.initialPages()>512) throw new IllegalArgumentException("initial memory too large");
   return new run.endive.runtime.ByteBufferMemory(new run.endive.wasm.types.MemoryLimits(limits.initialPages(), Math.min(limits.maximumPages(),512)));
  }).addBuiltins(Api_Builtins.toBuiltins(new Api())).build();
  long start=System.nanoTime();
  try(var runner=Runner.builder().withEngine(engine).withTimeoutMs(500).withCompilationTimeoutMs(5000).build()) {
   runner.compileAndExec(args[0]);
   System.out.println("OUTPUT: "+runner.stdout());
  } catch(Exception e) {System.out.println("ERROR: "+e.getMessage());}
  System.out.println("elapsed_ms="+(System.nanoTime()-start)/1000000);
 }
}

Les dépendances io.roastedroot:quickjs4j:0.1.0 et io.roastedroot:quickjs4j-annotations:0.1.0 vont dans les dépendances Maven ; io.roastedroot:quickjs4j-processor:0.1.0 va dans annotationProcessorPaths du compilateur. L’exécution de la recette utilise aussi -Xmx128m dans une JVM séparée. Ce plafond de tas et le plafond Wasm ne limitent pas toute la mémoire native ni tous les accès du processus.

Ce que les cinq essais établissent, et ce qu’ils laissent ouvert

Cinq scripts ont été passés au lanceur. Chacun teste une seule propriété :

Script de recetteRésultat observéCe qu’il établit
console.log(rapport.lire("D42"))Objet JSON avec 12 000 centimesLe pont hôte fonctionne
rapport.lire("D99")Erreur « document hors mandat »La fonction contrôle l’identifiant demandé
console.log(typeof fetch, typeof require)undefined undefinedCes deux interfaces ne sont pas exposées par cette configuration
while(true) {}Timeout, retour du lanceur en environ 511 msLe lanceur rend la main sur timeout pour cette boucle, dans la JVM de démonstration
Allocations répétées de tableauxErreur d’exécution contenant « out of memory », retour en environ 131 msLe plafond de mémoire linéaire arrête cet essai

Ces durées sont des observations d’une exécution locale, pas des objectifs de performance. L’erreur de mémoire est un diagnostic du runtime, pas une erreur métier élégante. L’application doit la traduire pour l’utilisateur et abandonner l’instance concernée.

Le plafond de mémoire linéaire a été ajouté après un premier essai : sans lui, l’allocation répétée n’avait pas rendu la main dans le délai de surveillance externe de quinze secondes. Le simple délai du Runner ne suffisait donc pas à qualifier ce cas. Le test borné ci-dessus ajoute la limite Wasm ; une supervision du processus reste utile pour contenir une défaillance du runtime.

Le retour du lanceur sur timeout ne prouve pas à lui seul que le calcul s’est arrêté. Chaque essai tournait dans sa propre JVM, qui s’est terminée après la réponse. Dans une application qui reste active, il faudrait observer la fin effective du travail, par exemple un processeur libéré et une instance abandonnée ; la recette ne l’a pas vérifié.

Le refus de D99, lui, appartient au Java hôte. Si la fonction lire acceptait n’importe quel identifiant, Wasm exécuterait cet accès autorisé par le pont. De même, l’absence de fetch ne prouve pas que toutes les fonctions hôtes seraient sans réseau. Le périmètre dépend exactement de celles que vous exposez. La réussite de cinq essais ne constitue pas un audit de sécurité.

Une fonction réseau contrôlée vaut mieux qu’un accès général

La recette n’expose aucune fonction réseau : le script ne peut faire aucun appel réseau par les interfaces exposées. Un rapport qui doit interroger une API a pourtant besoin d’une sortie. Les protections décrites dans cette section et la suivante n’ont pas été réalisées dans la recette ; elles décrivent ce qu’il reste à construire.

Cette sortie a sa place dans une fonction hôte de type fetch, seule voie réseau du script. L’application vérifie alors la destination, la méthode demandée, les autorisations et la taille des échanges avant d’envoyer la requête.

Une liste d’hôtes autorisés est un premier filtre. Il faut aussi traiter les adresses internes, la résolution DNS et les redirections selon le périmètre voulu. Refuser les redirections automatiques évite qu’une adresse autorisée renvoie discrètement vers une destination interdite.

Les délais doivent être limités : connexion, attente de réponse et durée totale de la tâche. Un plafond sur les corps reçus empêche un serveur distant de faire grossir la mémoire sans borne.

Les secrets sont ajoutés côté Java au moment de l’appel. Le script ne reçoit ni la clé ni un accès général au stockage des identifiants. L’application associe chaque secret à son utilisateur et à sa destination ; elle contrôle les en-têtes que le script peut fournir.

Sur un poste professionnel, cette fonction réseau doit aussi appliquer la configuration imposée par l’organisation : proxy d’entreprise, destinations permises et identité autorisée. Le script passe ainsi par les contrôles prévus pour les autres clients du SI.

Cette fonction porte le nom d’une interface connue sans en avoir tout le comportement. QuickJS n’est pas à lui seul un navigateur ni Node.js : l’essai typeof fetch l’a montré. Des interfaces comme fetch, URL ou FormData doivent être fournies ou adaptées par l’environnement. Une couche d’initialisation, parfois appelée prélude, peut installer ces fonctions avant le script. Sa documentation doit préciser les différences avec les API habituelles. Un fetch synchrone, par exemple, ne se comporte pas exactement comme celui du navigateur.

Limiter le temps, la mémoire et la concurrence

Un plafond de mémoire et une durée maximale répondent à deux risques différents, que la recette a séparés. La mémoire peut être épuisée très vite ; une boucle peut consommer du processeur sans allouer davantage. Le moteur doit pouvoir interrompre les deux cas.

Ces limites doivent couvrir les fonctions hôtes autant que possible. Un script arrêté ne doit pas laisser un appel réseau ou un traitement Java poursuivre indéfiniment son travail.

Le plafond de mémoire linéaire, lui, ne borne que la mémoire du module Wasm. La sortie de console.log, que le lanceur récupère sous forme de chaîne Java par runner.stdout(), et les objets que construisent les fonctions hôtes vivent dans le tas de la JVM, hors de ce plafond. L’option -Xmx128m bornait le tas de la JVM de démonstration ; dans une application qui partage son processus avec le script, épuiser ce tas toucherait toute l’application. Il faut donc aussi borner la taille des sorties, des résultats renvoyés par les fonctions hôtes et de leurs allocations. La recette ne l’a pas testé.

Il faut enfin limiter le nombre d’exécutions simultanées. Même des scripts individuellement bornés peuvent saturer le poste s’ils sont trop nombreux. Une file d’attente limitée ou un refus temporaire explicite permet de protéger le reste de l’application.

Vérifiez ces protections avec une boucle infinie, une allocation excessive, un serveur qui ne répond pas et plusieurs scripts lancés ensemble. Les deux premiers essais figurent dans la recette, chacun dans une JVM lancée pour l’occasion ; les deux autres restent à mener, et tous devraient l’être dans un processus qui reste actif. L’objectif est de constater un arrêt contrôlé, sans bloquer l’application qui les héberge.

WebAssembly ne remplace pas toutes les frontières d’isolation

Le bac à sable de WebAssembly limite les interactions du module avec son environnement. La même documentation de sécurité en signale les limites : la sémantique de WebAssembly n’écarte pas toutes les classes de bugs, et des attaques par canal auxiliaire, par exemple sur les temps d’exécution, restent possibles. L’isolement dépend aussi de la correction du runtime, ici de la traduction en bytecode Java, et des fonctions exposées. Les accès autorisés peuvent eux-mêmes être utilisés de façon indésirable.

Une exécution dans la JVM partage enfin le processus de l’application. Pour du code nécessitant des capacités système, des bibliothèques natives ou une isolation plus forte, un processus, un conteneur durci ou une autre frontière peut rester nécessaire.

Ce que la recette permet de conclure

Pour le script de rapport du début, la recette montre qu’un moteur JavaScript peut tourner dans la JVM sans fetch ni require, avec une seule fonction de lecture qui refuse ce qui sort du mandat, un lanceur qui rend la main face à une boucle infinie et une mémoire Wasm plafonnée. Elle ne montre ni la sortie réseau, ni la limite de concurrence, ni l’arrêt effectif du calcul dans un processus qui reste actif, ni les limites des sorties et des fonctions hôtes : ces protections restent à construire et à éprouver. Le choix repose donc sur les capacités à offrir et les conséquences d’une défaillance. Un moteur léger convient à des scripts bornés ; il ne justifie pas de leur ouvrir des accès que vous ne sauriez pas contrôler.

Sources

Explorer

Sur le même sujet

Choisis dans l’index d’après les étiquettes de cet article — les plus proches d’abord, hors de sa série. Rien n’est écrit à la main : un article publié demain avec les mêmes étiquettes y prendra place.

Laisser un commentaire

Elle n'est jamais affichée ni publiée. Elle sert à regrouper vos commentaires et, si vous vous inscrivez un jour avec elle, à vous les rendre.

Votre commentaire sera relu avant d'être publié.