0Pricing
Lua Academy · Leçon

Construire un bac à sable restreint

Créez une liste blanche _ENV sûre et exécutez du code non fiable avec load().

Construire un bac à sable restreint est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Objectif

Un bac à sable restreint vous permet d’exécuter du code Lua non fiable en toute sécurité : il peut effectuer des calculs et utiliser les chaînes et les fonctions mathématiques, mais ne peut pas accéder au système de fichiers, au OS ou au réseau.

Approche par liste blanche

Construisez l’environnement du bac à sable à partir de zéro, en n’y incluant que des fonctions sûres et bien comprises.

local function makeSandbox()
  return {
    print   = print,
    type    = type,
    tostring = tostring,
    tonumber = tonumber,
    pairs   = pairs,
    ipairs  = ipairs,
    next    = next,
    select  = select,
    unpack  = table.unpack,
    error   = error,
    pcall   = pcall,
    xpcall  = xpcall,
    math    = math,
    string  = { format=string.format, find=string.find,
                match=string.match, gmatch=string.gmatch,
                gsub=string.gsub, sub=string.sub,
                len=string.len, byte=string.byte, char=string.char },
    table   = { insert=table.insert, remove=table.remove,
                concat=table.concat, sort=table.sort,
                unpack=table.unpack, move=table.move },
  }
end

Exécution du code dans le bac à sable

Chargez et exécutez le code utilisateur avec le bac à sable comme valeur de _ENV.

local function runSandboxed(code, env)
  local fn, err = load(code, "user", "t", env)
  if not fn then return nil, err end
  return pcall(fn)
end
local env = makeSandbox()
local ok, err = runSandboxed("return 1+1", env)
print(ok, err)  -- true  2

Capture de la sortie

Remplacez print par une fonction personnalisée qui ajoute les données à un tampon au lieu de les écrire sur stdout.

local output = {}
env.print = function(...)
  local parts = {}
  for i = 1, select("#", ...) do
    parts[i] = tostring(select(i, ...))
  end
  output[#output+1] = table.concat(parts, "\t")
end

Retour de valeurs

Pour permettre au code exécuté dans le bac à sable de renvoyer des valeurs, appelez le bloc de code compilé comme une fonction et récupérez les valeurs qu’il renvoie.

local fn = load("return math.sqrt(144)", "user", "t", env)
if fn then
  local ok, result = pcall(fn)
  print(ok, result)  -- true  12.0
end

Blocage des contournements par métaméthodes

Le code exécuté dans le bac à sable ne doit pas obtenir de références vers des métatables ou vers rawget/rawset, afin d’éviter de contourner les restrictions sur les champs.

Limitation de la longueur des chaînes

Redéfinissez les opérations sur les chaînes pour limiter la longueur de la sortie et empêcher les attaques par déni de service dues à l’allocation de chaînes volumineuses.

Limites de ressources avec debug.sethook

Ajoutez un crochet comptant les instructions afin de terminer le code qui s’emballe.

local function sandboxWithLimit(code, env, maxOps)
  local ops = 0
  debug.sethook(function()
    ops = ops + 1
    if ops > maxOps then error("Instruction limit exceeded") end
  end, "", 100)
  local result = table.pack(runSandboxed(code, env))
  debug.sethook()
  return table.unpack(result, 1, result.n)
end

Tests du bac à sable

Écrivez des tests qui tentent des vecteurs d’évasion connus : accéder à _G, appeler load, utiliser debug, et vérifiez qu’ils échouent tous.

Vecteurs d’évasion connus

Les voies d’évasion courantes sont les suivantes : string.rep("x",2^30) (déni de service par saturation de la mémoire), ({}).__index sur des objets standard, debug via la métatable des chaînes, et io via package.loaded.

Question sur le bac à sable

Pourquoi un bac à sable n’inclut-il pas load ou dofile ?

Récapitulatif : création d’un bac à sable restreint

N’autorisez dans une table env personnalisée que les fonctions sûres. Utilisez load(code, name, "t", env). Ajoutez un comptage des instructions avec debug.sethook. Testez les vecteurs d’évasion. N’incluez jamais load, dofile, debug ni l’accès à la table globale.

Questions Fréquemment Posées

La leçon « Construire un bac à sable restreint » est-elle gratuite ?

Oui — le texte complet de « Construire un bac à sable restreint » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Construire un bac à sable restreint » ?

Créez une liste blanche _ENV sûre et exécutez du code non fiable avec load(). Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Construire un bac à sable restreint » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Le modèle _ENV de Lua 5.2+
  2. Construire un bac à sable restreint
  3. Empêcher les sorties du bac à sable
  4. Limites de ressources et instrumentation
← Retour à Lua Academy