Lua Academy · Aula

Criando um sandbox restrito

Crie uma lista de permissões segura em _ENV e execute código não confiável com load().

Aula 2 de 412 etapas

Criando um sandbox restrito é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

Objetivo

Um sandbox restrito permite executar código Lua não confiável com segurança: ele pode realizar cálculos e usar strings e matemática, mas não pode acessar o sistema de arquivos, o OS ou a rede.

Abordagem de lista de permissões

Crie o ambiente do sandbox do zero, incluindo somente funções seguras e bem compreendidas.

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

Execução de código no sandbox

Carregue e execute o código do usuário com o sandbox como seu _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

Captura da saída

Substitua print por uma função personalizada que anexe o conteúdo a um buffer em vez de escrevê-lo na saída padrão.

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

Retorno de valores

Para permitir que o código do sandbox retorne valores, chame o trecho compilado como uma função e capture os valores retornados.

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

Bloqueio de explorações de metamétodos

O código do sandbox não deve receber referências a metatabelas nem a rawget/rawset, para evitar o contorno das restrições de campos.

Limitação do tamanho das strings

Substitua as operações de strings para limitar o tamanho da saída e evitar DoS por meio de alocações enormes de strings.

Limites de recursos com debug.sethook

Adicione um gancho de contagem de instruções para encerrar código que não termina.

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

Teste do sandbox

Escreva testes que tentem vetores de escape conhecidos: acessar _G, chamar load, usar debug e verificar se todos falham.

Vetores de escape conhecidos

Rotas de escape comuns: string.rep("x",2^30) (DoS de memória), ({}).__index em objetos padrão, debug por meio da metatabela de strings e io por meio de package.loaded.

Pergunta sobre o sandbox

Por que um sandbox não inclui load nem dofile?

Responda na aula interativa

Recapitulação: criação de um sandbox restrito

Inclua na lista de permissões somente funções seguras em uma tabela de ambiente personalizada. Use load(code, name, "t", env). Adicione a contagem de instruções com debug.sethook. Teste os vetores de escape. Nunca inclua load, dofile, debug nem acesso à tabela global.

Grátis para começar

Aprenda Lua com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 40
Aulas: 159

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Criando um sandbox restrito” é grátis?

Sim — o texto completo de “Criando um sandbox restrito” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Criando um sandbox restrito”?

Crie uma lista de permissões segura em _ENV e execute código não confiável com load(). Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Criando um sandbox restrito”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Lua Academy