0Pricing
Lua Academy · Leçon

Mettre les modules d’extension en bac à sable

Exécutez les modules d’extension dans des environnements restreints avec setfenv/load et un _ENV personnalisé.

Mettre les modules d’extension en bac à sable est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Pourquoi mettre les plug-ins en bac à sable ?

Du code de plug-in non fiable peut appeler des fonctions dangereuses (os.execute, io.open, load) ou accéder à l’état privé de l’application. Un bac à sable limite ce que le code peut faire.

_ENV personnalisé dans Lua 5.2+

Dans Lua 5.2+, l’environnement global de chaque bloc est _ENV. Chargez un bloc avec un _ENV restreint afin de limiter son accès.

local function sandbox(code, env)
  local chunk, err = load(code, "sandbox", "t", env)
  if not chunk then return nil, err end
  return pcall(chunk)
end

Créer un environnement sûr

Créez un environnement avec liste blanche contenant uniquement des fonctions sûres de la bibliothèque standard.

local safeEnv = {
  print  = print,
  type   = type,
  pairs  = pairs,
  ipairs = ipairs,
  tostring = tostring,
  tonumber = tonumber,
  table  = {insert=table.insert, concat=table.concat, sort=table.sort},
  string = {format=string.format, find=string.find, match=string.match},
  math   = math,
}

Bloquer les fonctions dangereuses

Excluez explicitement : os, io, load, loadfile, dofile, require, debug. Ne les copiez pas dans safeEnv.

Charger des fichiers dans le bac à sable

Chargez un fichier de plug-in et exécutez-le dans l’environnement du bac à sable.

local function sandboxFile(path, env)
  local chunk, err = loadfile(path, "t", env)
  if not chunk then return nil, err end
  local ok, result = pcall(chunk)
  if not ok then return nil, result end
  return result
end

Fournir un accès à l’API

Donnez aux plug-ins isolés un accès à une API d’application restreinte en incluant uniquement des méthodes sûres dans l’environnement.

local pluginEnv = setmetatable({
  app = {
    on       = function(e,f) app:on(e,f) end,
    emit     = function(e,...) app:emit(e,...) end,
    log      = function(msg) app:log(msg) end,
  },
}, {__index = safeEnv})

Empêcher l’accès à _ENV

N’incluez pas _G, _ENV ou load dans le bac à sable. Ces éléments permettent de s’échapper de l’environnement restreint.

Compter les instructions avec debug.sethook

Empêchez les boucles infinies en comptant les instructions exécutées et en interrompant l’exécution après une limite.

local function withLimit(fn, maxInstructions)
  local count = 0
  debug.sethook(function()
    count = count + 1
    if count > maxInstructions then
      error("Instruction limit exceeded")
    end
  end, "", 100)
  local ok, err = pcall(fn)
  debug.sethook()
  return ok, err
end

Limite mémoire

Combinez le comptage des instructions avec des vérifications périodiques de collectgarbage("count") afin d’interrompre l’exécution si l’utilisation de la mémoire dépasse un seuil.

Capture de la sortie

Remplacez print dans l’environnement du bac à sable par une fonction personnalisée qui capture la sortie dans un tampon au lieu de l’écrire sur la sortie standard.

Échappatoires du bac à sable à éviter

Vecteurs d’évasion connus : debug.getupvalue, getmetatable appliqué aux objets standard, et coroutine.wrap autour de code dangereux. Examinez attentivement toutes les entrées de l’environnement.

Question sur le bac à sable

Comment empêcher le code isolé dans le bac à sable d’appeler os.execute ?

Récapitulatif : mise en bac à sable des plug-ins

Créez un _ENV avec liste blanche contenant uniquement des API sûres. Chargez le code du plug-in avec load(code, name, "t", safeEnv). Utilisez le comptage des instructions pour empêcher les boucles infinies. N’incluez jamais load, debug ou _G dans le bac à sable.

Questions Fréquemment Posées

La leçon « Mettre les modules d’extension en bac à sable » est-elle gratuite ?

Oui — le texte complet de « Mettre les modules d’extension en bac à sable » 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 « Mettre les modules d’extension en bac à sable » ?

Exécutez les modules d’extension dans des environnements restreints avec setfenv/load et un _ENV personnalisé. 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 3 sur 4.

Combien de temps prend la leçon « Mettre les modules d’extension en bac à sable » ?

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. Découverte et chargement de modules d’extension
  2. API de modules d’extension et système de hooks
  3. Mettre les modules d’extension en bac à sable
  4. Gestion des versions et des dépendances
← Retour à Lua Academy