-- Niveau 1 : environnement restreint (rappel), mais insuffisant seul
local function baseSandbox()
    return {
        print = print, pairs = pairs, ipairs = ipairs, tostring = tostring,
        string = { format = string.format, sub = string.sub, len = string.len },  -- sous-ensemble, pas la lib entière
        math = math, table = { insert = table.insert, remove = table.remove },
    }
end

-- Piège d'évasion classique : la bibliothèque "debug" permet de remonter à l'environnement global réel
-- même depuis un chunk chargé avec un _ENV restreint -> NE JAMAIS l'exposer dans un sandbox
local malicious = [[
local d = debug   -- si debug est accessible, tout le sandboxing est contournable
local realEnv = d.getupvalue(some_upvalue_holder, 1)
]]

-- Niveau 2 : limiter la mémoire allouée par le sandbox (collectgarbage avec un budget)
local function runWithMemoryLimit(fn, maxKB)
    collectgarbage("collect")
    local before = collectgarbage("count")   -- mémoire utilisée par Lua, en Ko

    local co = coroutine.create(fn)
    local ok, err = coroutine.resume(co)

    local after = collectgarbage("count")
    if (after - before) > maxKB then
        error(string.format("Sandbox: limite mémoire dépassée (%.1f Ko utilisés, max %d Ko)", after - before, maxKB))
    end
    return ok, err
end

-- Niveau 3 : limiter le temps d'exécution avec un hook d'instructions (évite une boucle infinie de bloquer le host)
local function runWithTimeout(untrustedCode, env, maxInstructions)
    local fn, loadErr = load(untrustedCode, "sandboxed_chunk", "t", env)
    if not fn then
        return false, "Erreur de compilation: " .. tostring(loadErr)
    end

    local co = coroutine.create(fn)
    -- le hook est posé sur la coroutine, pas globalement : n'affecte pas le reste du programme hôte
    debug.sethook(co, function()
        error("Sandbox: limite d'instructions dépassée (script suspendu, boucle infinie suspectée)")
    end, "", maxInstructions)

    return coroutine.resume(co)
end

local untrusted = "while true do end"  -- boucle infinie volontaire pour test
local ok, err = runWithTimeout(untrusted, baseSandbox(), 500000)
print(ok, err)   -- false   Sandbox: limite d'instructions dépassée...

-- Niveau 4 : liste blanche stricte de fonctions "sûres", refuser tout le reste explicitement
local DANGEROUS_GLOBALS = {
    "load", "loadstring", "dofile", "loadfile",   -- exécution de code arbitraire
    "require", "collectgarbage", "debug",          -- accès système / évasion
    "io", "os", "package",                          -- accès disque/process/modules
}

local function assertNoLeaks(sandboxEnv)
    for _, name in ipairs(DANGEROUS_GLOBALS) do
        assert(sandboxEnv[name] == nil, "Fuite de sécurité: '" .. name .. "' est accessible dans le sandbox !")
    end
end

assertNoLeaks(baseSandbox())   -- à exécuter en test automatisé à chaque modification du sandbox