0Pricing
Lua Academy · Lekcja

Sandboxowanie wykonywania pluginów

Proszę uruchamiać pluginy w ograniczonych środowiskach za pomocą setfenv/load z niestandardowym _ENV.

Sandboxowanie wykonywania pluginów to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 3 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.

Dlaczego izolować wtyczki w piaskownicy?

Niezaufany kod wtyczki może wywoływać niebezpieczne funkcje (os.execute, io.open, load) lub uzyskiwać dostęp do prywatnego stanu aplikacji. Piaskownica ogranicza możliwości kodu.

Własne _ENV w Lua 5.2+

W Lua 5.2+ globalnym środowiskiem każdego chunka jest _ENV. Należy załadować chunk z ograniczonym _ENV, aby ograniczyć jego dostęp.

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

Budowanie bezpiecznego środowiska

Należy utworzyć środowisko z białą listą zawierające tylko bezpieczne funkcje biblioteki standardowej.

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,
}

Blokowanie niebezpiecznych funkcji

Należy jawnie wykluczyć: os, io, load, loadfile, dofile, require, debug. Nie należy kopiować ich do safeEnv.

Ładowanie plików w piaskownicy

Należy załadować plik wtyczki i wykonać go w środowisku piaskownicy.

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

Udostępnianie dostępu do API

Należy udostępnić wtyczkom działającym w piaskownicy ograniczone API aplikacji, umieszczając w środowisku wyłącznie bezpieczne metody.

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})

Zapobieganie dostępowi do _ENV

Nie należy umieszczać _G, _ENV ani load w piaskownicy. Umożliwiają one ucieczkę z ograniczonego środowiska.

Zliczanie instrukcji za pomocą debug.sethook

Należy zapobiegać nieskończonym pętlom, zliczając wykonane instrukcje i przerywając działanie po przekroczeniu limitu.

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

Limit pamięci

Należy połączyć zliczanie instrukcji z okresowymi kontrolami collectgarbage("count"), aby przerwać działanie po przekroczeniu progu użycia pamięci.

Przechwytywanie danych wyjściowych

Należy zastąpić print w środowisku piaskownicy własną funkcją, która przechwytuje dane wyjściowe do bufora zamiast zapisywać je na stdout.

Unikanie sposobów ucieczki z piaskownicy

Znane sposoby ucieczki to: debug.getupvalue, getmetatable użyte na standardowych obiektach oraz coroutine.wrap dla niebezpiecznego kodu. Należy dokładnie przeanalizować wszystkie wpisy środowiska.

Pytanie o piaskownicę

Jak uniemożliwić kodowi działającemu w piaskownicy wywołanie os.execute?

Podsumowanie: izolowanie wtyczek w piaskownicy

Należy utworzyć białą listę _ENV zawierającą wyłącznie bezpieczne interfejsy API. Kod wtyczki należy ładować za pomocą load(code, name, "t", safeEnv). Należy używać zliczania instrukcji, aby zapobiegać nieskończonym pętlom. W piaskownicy nigdy nie należy umieszczać load, debug ani _G.

Często zadawane pytania

Czy lekcja „Sandboxowanie wykonywania pluginów” jest bezpłatna?

Tak — pełny tekst „Sandboxowanie wykonywania pluginów” 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 „Sandboxowanie wykonywania pluginów”?

Proszę uruchamiać pluginy w ograniczonych środowiskach za pomocą setfenv/load z niestandardowym _ENV. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Sandboxowanie wykonywania pluginów”?

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

  1. Wyszukiwanie i ładowanie pluginów
  2. API pluginów i system hooków
  3. Sandboxowanie wykonywania pluginów
  4. Wersjonowanie i zarządzanie zależnościami
← Powrót do Lua Academy