Limits put to the testLes limites à l’épreuve

A hook that counts bytecode is not enough to limit every Lua script. Here are runnable reproductions, side by side.Un hook qui compte le bytecode ne suffit pas à limiter tous les scripts Lua. Voici des reproductions exécutables, côte à côte.

The upstream column uses Fengari 0.1.5, as published on npm, with a host hook of 20,000 instructions. Pyroeis uses its limits API with the same budget, 200 ms, a 1 MiB ceiling per allocation and 4 MiB accumulated per call.La colonne amont utilise Fengari 0.1.5, tel que publié sur npm, avec un hook hôte de 20 000 instructions. Pyroeis utilise son API limits avec le même budget, 200 ms, un plafond de 1 Mio par allocation et 4 Mio cumulés par appel.

This session’s resultsRésultats de cette session

What these cases showCe que ces cas démontrent

Pattern searches and table.move can monopolise a native function without yielding to the bytecode hook. A hook error can also be caught by pcall, or trigger an xpcall handler unchecked. This becomes a denial-of-service risk when the host runs untrusted scripts relying on that hook alone.Les recherches de motifs et table.move peuvent monopoliser une fonction native sans rendre la main au hook de bytecode. Une erreur de hook peut aussi être attrapée par pcall, ou déclencher un gestionnaire xpcall sans contrôle. Cela devient un risque de déni de service lorsque l’hôte exécute des scripts non fiables en se reposant sur ce seul hook.

Upstream Fengari does not provide Pyroeis’s sandbox or limits API. The adapter used here removes sensitive libraries and adds a hook; it does not claim to be an official Fengari sandbox. The allocation case shows protection added by Pyroeis, not an upstream security commitment.Fengari amont ne fournit pas l’API sandbox ou limits de Pyroeis. L’adaptateur utilisé ici retire les bibliothèques sensibles et ajoute un hook ; il ne prétend pas être un sandbox officiel Fengari. Le cas d’allocation illustre une protection ajoutée par Pyroeis, plutôt qu’un engagement de sécurité de l’amont.

The old @datamoc/fengari defects (exposed file helpers, limits on global paths and on Coroutine#close) concern our former package and are described in its history. They are not attributed to Fengari 0.1.5. These reproductions are not an exhaustive audit.Les anciens défauts de @datamoc/fengari (helpers de fichiers exposés, limites sur les chemins globaux et sur Coroutine#close) concernent notre ancien paquet et sont décrits dans son historique. Ils ne sont pas attribués à Fengari 0.1.5. Ces reproductions ne constituent pas un audit exhaustif.

Untrusted Lua in games: why the bridge is differentLua non fiable dans les jeux : pourquoi le pont est différent

Many games and tools let players write Lua: strategies, bots, mods, quest scripts. That code comes from people the host does not know. It still has to talk to the game, so the real question is what the script is allowed to touch.Beaucoup de jeux et d’outils laissent les joueurs écrire du Lua : stratégies, bots, mods, scripts de quêtes. Ce code vient de personnes que l’hôte ne connaît pas. Il doit pourtant dialoguer avec le jeu ; la vraie question est donc ce que le script a le droit de toucher.

fengari-interop answers a different need: it gives Lua the JavaScript world. Its js module exposes the global object and lets Lua construct, read, write and call any JavaScript value. That is convenient for trusted scripts, and unacceptable for untrusted ones: a script that reaches js.global reaches everything the page or worker can reach, including eval and Function, network access, storage and the DOM. No limit on instructions or allocations changes that, because the script no longer needs to stay inside the Lua engine. That is why the upstream adapter on this page removes the interop, and why games with untrusted scripts cannot use it.fengari-interop répond à un autre besoin : il donne à Lua le monde JavaScript. Son module js expose l’objet global et permet à Lua de construire, lire, écrire et appeler n’importe quelle valeur JavaScript. C’est pratique pour des scripts de confiance, et inacceptable pour des scripts non fiables : un script qui atteint js.global atteint tout ce que la page ou le worker peut atteindre, y compris eval et Function, le réseau, le stockage et le DOM. Aucune limite d’instructions ou d’allocations n’y change rien, puisque le script n’a plus besoin de rester dans le moteur Lua. C’est pourquoi l’adaptateur amont de cette page retire l’interop, et pourquoi les jeux qui exécutent des scripts non fiables ne peuvent pas l’utiliser.

Pyroeis uses an exchange mode instead. The host decides what exists on the Lua side:Pyroeis adopte donc un mode d’échange. L’hôte décide de ce qui existe côté Lua :

• The sandbox preset opens only base, coroutine, table, string, utf8 and math. There is no os, io, debug, package or require, and load accepts text only.Le preset sandbox n’ouvre que base, coroutine, table, string, utf8 et math. Il n’y a ni os, ni io, ni debug, ni package, ni require, et load n’accepte que du texte.
• The script sees only the functions registered with defineFunction, such as host.scale or host.choose. Each one validates its arguments before acting.Le script ne voit que les fonctions déclarées avec defineFunction, comme host.scale ou host.choose. Chacune valide ses arguments avant d’agir.
• Values cross the boundary as copies: tables become arrays, objects or maps, and a __proto__ key stays an ordinary key. Lua never receives a reference to a JavaScript object, so it cannot walk to a constructor or a prototype.Les valeurs traversent la frontière sous forme de copies : les tables deviennent des tableaux, objets ou maps, et une clé __proto__ reste une clé ordinaire. Lua ne reçoit jamais de référence vers un objet JavaScript, il ne peut donc pas remonter vers un constructeur ou un prototype.
• A host function can suspend the script with Yield, for example to wait for a player’s answer, and resume it later. See the dialogue example and the MWG robot, whose scripts run in terminable workers.Une fonction hôte peut suspendre le script avec Yield, par exemple pour attendre la réponse d’un joueur, puis le reprendre. Voir l’exemple de dialogue et le robot MWG, dont les scripts tournent dans des workers que l’on peut arrêter.

This protects the host, not the host’s own callbacks: a function you register can still do harm if it trusts its arguments. The Lua-to-JavaScript translator is a different tool. Its output is ordinary JavaScript, where Lua globals such as eval or Function keep their JavaScript meaning, and t.__proto__.x = 1 changes Object.prototype. Run translated code only if you wrote or reviewed the Lua. The translator flags these constructs as unsafe, and the Lua ↔ JavaScript page refuses to run such a translation.Cela protège l’hôte, pas ses propres callbacks : une fonction que vous déclarez peut encore nuire si elle fait confiance à ses arguments. Le traducteur Lua vers JavaScript est un autre outil. Sa sortie est du JavaScript ordinaire, où des globaux Lua comme eval ou Function gardent leur sens JavaScript, et où t.__proto__.x = 1 modifie Object.prototype. N’exécutez du code traduit que si vous avez écrit ou relu le Lua. Le traducteur signale ces constructions comme unsafe, et la page Lua ↔ JavaScript refuse d’exécuter une telle traduction.

Data exchange cases that require fengari-interopCas d’échange de données nécessitant fengari-interop

For use cases that require full, bidirectional access between Lua and JavaScript — such as Lua scripts that need to directly manipulate JavaScript objects, call arbitrary JavaScript functions, or access browser APIs like the DOM or fetch — you must use fengari-interop. Pyroeis’s exchange model deliberately does not provide this capability, as it would break the security isolation required for untrusted scripts.Pour les cas d’usage qui nécessitent un accès bidirectionnel complet entre Lua et JavaScript — comme des scripts Lua devant manipuler directement des objets JavaScript, appeler des fonctions JavaScript arbitraires, ou accéder à des API navigateur comme le DOM ou fetch — vous devez utiliser fengari-interop. Le modèle d’échange de Pyroeis ne fournit pas intentionnellement cette capacité, car elle briserait l’isolation de sécurité requise pour les scripts non fiables.

With fengari-interop, Lua code can access js.global, which exposes the entire JavaScript environment including eval, Function, network access, storage and the DOM. This is only safe when the Lua code is fully trusted by the host. For untrusted Lua scripts, Pyroeis’s exchange model — with its explicit data copying and host-controlled function exposure — is the appropriate choice.Avec fengari-interop, le code Lua peut accéder à js.global, qui expose tout l’environnement JavaScript y compris eval, Function, l’accès réseau, le stockage et le DOM. Cela n’est sûr que lorsque le code Lua est entièrement de confiance pour l’hôte. Pour les scripts Lua non fiables, le modèle d’échange de Pyroeis — avec sa copie explicite des données et son exposition contrôlée des fonctions hôte — est le choix approprié.

In summary: if you need Lua to directly interact with the JavaScript runtime, use fengari-interop with trusted scripts only. If you need to safely run untrusted Lua that exchanges data with JavaScript, use Pyroeis’s exchange model as documented on the JS ↔ Lua page.En résumé : si vous avez besoin que Lua interagisse directement avec l’environnement JavaScript, utilisez fengari-interop uniquement avec des scripts de confiance. Si vous devez exécuter du Lua non fiable qui échange des données avec JavaScript, utilisez le modèle d’échange de Pyroeis tel que documenté sur la page JS ↔ Lua.

Corrupted binary chunksChunks binaires corrompus

Lua can load precompiled code with load(chunk, name, "b"). Upstream Fengari 0.1.5 accepts a binary chunk from any script, and the loader and VM assume it is well-formed. This demonstration takes one valid chunk, corrupts one to four bytes at random, and gives it to the same Lua script on both engines. The script loads the chunk and runs it under pcall, so every failure should end as a Lua error.Lua peut charger du code précompilé avec load(chunk, nom, "b"). Fengari 0.1.5 amont accepte un chunk binaire venant de n’importe quel script, et le chargeur comme la VM supposent qu’il est bien formé. Cette démonstration prend un chunk valide, corrompt un à quatre octets au hasard, et le donne au même script Lua sur les deux moteurs. Le script charge le chunk et l’exécute sous pcall : tout échec devrait donc finir en erreur Lua.

With upstream, some corrupted chunks make the engine throw a JavaScript RangeError, Error or TypeError that crosses pcall and reaches the host. We found no code execution; the effect is a host that must catch non-Lua exceptions, and an engine in an undefined state. The Pyroeis sandbox does not parse untrusted binary chunks: load is text-only, so each attempt ends as a Lua error. Outside the sandbox, Pyroeis checks every register, constant, jump and upvalue of a binary chunk when it loads it, which stops a corrupted chunk from stalling the VM inside one instruction, but a binary chunk is still trusted input.Avec l’amont, certains chunks corrompus font lever par le moteur une RangeError, une Error ou une TypeError JavaScript qui traverse pcall et atteint l’hôte. Nous n’avons trouvé aucune exécution de code ; l’effet est un hôte qui doit attraper des exceptions non Lua, et un moteur dans un état indéfini. Le sandbox Pyroeis n’analyse pas les chunks binaires non fiables : load n’accepte que du texte, chaque tentative finit donc en erreur Lua. Hors du sandbox, Pyroeis vérifie à chaque chargement les registres, constantes, sauts et upvalues d’un chunk binaire, ce qui empêche un chunk corrompu d’immobiliser le VM dans une seule instruction, mais un chunk binaire reste une entrée de confiance.

local f, err = load(mutated(), '=mutated', 'b')
if not f then return 'refused: ' .. tostring(err) end
local ok, res = pcall(f)
return ok and 'ran' or 'lua-error: ' .. tostring(res)

The proposed test matrix, checked against realityLa matrice de tests proposée, confrontée à la réalité

A first draft compared the engines with nine attacks and pre-written outcomes. The list is kept below, with the behaviour both codes really have and a way to verify each row yourself. Three rows were corrected: the Lua chunk format carries no checksum, t.__proto__ written from Lua is an ordinary key that touches nothing else, and js.global exists only when a host loads fengari-interop. One row was set aside on purpose: rejecting constants that mention eval would break legitimate scripts and would stop nobody, since a Lua string is data and no JavaScript bridge exists to reach. Eight of the ten rows are runnable in the comparison above, and only where the two engines behave differently; each result appears under “This session’s results”.Un premier jet comparait les moteurs avec neuf attaques et des résultats précrits. La liste est conservée ci-dessous, avec le comportement réel des deux codes, et un moyen de vérifier chaque ligne vous-même. Trois lignes ont été corrigées : le format des chunks Lua ne porte pas de checksum, t.__proto__ écrit depuis Lua est une clé ordinaire qui ne touche rien d’autre, et js.global n’existe que si un hôte charge fengari-interop. Une ligne a été écartée à dessein : rejeter les constantes qui mentionnent eval casserait des scripts légitimes et n’arrêterait personne, une chaîne Lua étant de la donnée et aucun pont JavaScript n’existant à atteindre. Huit des dix lignes sont exécutables dans la comparaison ci-dessus, et seulement là où les deux moteurs se comportent différemment ; chaque résultat apparaît sous « Résultats de cette session ».