Lua Academy · Lekcja

Tworzenie ograniczonego sandboxa

Proszę utworzyć bezpieczną białą listę _ENV i wykonywać niezaufany kod za pomocą load().

Tworzenie ograniczonego sandboxa to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Lua Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Lua Academy zawiera 4 lekcji w sumie.

Cel

Ograniczona piaskownica pozwala bezpiecznie uruchamiać niezaufany kod Lua: kod może wykonywać obliczenia oraz korzystać z ciągów znaków i matematyki, ale nie może uzyskiwać dostępu do systemu plików, systemu operacyjnego ani sieci.

Podejście oparte na białej liście

Środowisko piaskownicy należy zbudować od podstaw, uwzględniając wyłącznie bezpieczne i dobrze zrozumiane funkcje.

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

Uruchamianie kodu w piaskownicy

Kod użytkownika należy załadować i wykonać, używając piaskownicy jako jego _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

Przechwytywanie danych wyjściowych

Należy zastąpić print niestandardową funkcją, która dopisuje dane do bufora zamiast zapisywać je na 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

Zwracanie wartości

Aby umożliwić kodowi uruchamianemu w piaskownicy zwracanie wartości, należy wywołać skompilowany fragment kodu jako funkcję i przechwycić zwracane wartości.

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

Blokowanie exploitów metametod

Kod uruchamiany w piaskownicy nie powinien otrzymywać odwołań do metatabel ani do rawget/rawset, aby nie obchodzić ograniczeń dostępu do pól.

Ograniczanie długości ciągów znaków

Należy zastąpić operacje na ciągach znaków, aby ograniczyć długość danych wyjściowych i zapobiec atakom DoS polegającym na alokowaniu ogromnych ciągów znaków.

Ograniczanie zasobów za pomocą debug.sethook

Należy dodać funkcję przechwytującą z licznikiem instrukcji, aby kończyć działanie kodu, który nie chce się zakończyć.

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

Testowanie piaskownicy

Należy napisać testy sprawdzające znane wektory ucieczki: dostęp do _G, wywołanie load i użycie debug, a następnie zweryfikować, że wszystkie te próby kończą się niepowodzeniem.

Znane wektory ucieczki

Typowe drogi ucieczki: string.rep("x",2^30) (DoS pamięci), ({}).__index na standardowych obiektach, debug za pośrednictwem metatabeli ciągów znaków, io za pośrednictwem package.loaded.

Pytanie dotyczące piaskownicy

Dlaczego piaskownica nie zawiera load ani dofile?

Podsumowanie: tworzenie ograniczonej piaskownicy

Na białej liście niestandardowej tabeli env należy umieścić wyłącznie bezpieczne funkcje. Należy użyć load(code, name, "t", env). Należy dodać zliczanie instrukcji za pomocą debug.sethook i przetestować wektory ucieczki. Nigdy nie należy dołączać load, dofile, debug ani dostępu do tabeli globalnej.

Często zadawane pytania

Czy lekcja „Tworzenie ograniczonego sandboxa” jest bezpłatna?

Tak — pełny tekst „Tworzenie ograniczonego sandboxa” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Lua Academy, przejdź na CoddyKit PRO. Kurs Lua Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Tworzenie ograniczonego sandboxa”?

Proszę utworzyć bezpieczną białą listę _ENV i wykonywać niezaufany kod za pomocą load(). Ćwiczysz Lua Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Lua Academy?

Nie wymagamy żadnego doświadczenia. Lua Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Tworzenie ograniczonego sandboxa”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Lua Academy?

Tak. Każda lekcja Lua Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Lua Academy