Skip to main content

OP-7 — Script engine spike: Lua vs Starlark vs expr (decision doc)

Дата: 2026-10-06. Лейн: OP-7 (imp-op7, worktree tokenrouter-imp-op7). Карточка: docs/plans/OUTPLAY-PLAN-2026-10-06.md §3 OP-7; решение owner 2026-10-06 п.4: «Lua, но почеленджи» — финальный выбор за owner по данным спайка. Work record: artifacts/imp/work/OP-7.md.

1. Что построено​

Три движка условий за ОДИН seam ConditionCompiler (pkg/pipeline/script.go:16, не менялся):

движокпакетдеп (обоснование)
luapkg/pipeline/script/luagithub.com/yuin/gopher-lua v1.1.2 — единственный поддерживаемый pure-Go Lua 5.1 VM, кандидат owner
starlarkpkg/pipeline/script/starlarkgo.starlark.net (github.com/google/starlark-go) — язык конфигов Bazel, индустриальный прецедент песочницы
exprpkg/pipeline/script/exprgithub.com/expr-lang/expr v1.17.8 — минимальный нетьюринговый язык выражений, fallback

Контракт env (корни findings/steps/meta, only-read, результат = bool) — pkg/pipeline/script/env.go, одинаков для всех трёх (смена языка не ломает YAML-модель политик; синтаксис условия меняется, семантика корней — нет).

Регистрация: Engine.Scripts().MustRegister("lua"|"starlark"|"expr", eng.Compile). Одиночный движок — дефолт для шагов без when_engine; несколько → when_engine обязателен (compile.go:134 compileWhen, контракт покрыт тестами для всех трёх).

2. Ключевые находки спайка (то, ради чего был «почеленджи»)​

F1. У Lua-кандидата НЕТ instruction-бюджета — планируемый механизм не существует​

План §3 OP-7(а) предполагал «бюджет инструкций (debug.sethook)». Факт: gopher-lua v1.1.2 не поддерживает debug hooks (README «Differences between Lua and GopherLua → Unsupported functions»; в модуле нет ни SetHook, ни hook-полей VM). Реальный примитив: VM проверяет LState.Context на КАЖДОЙ инструкции (mainLoopWithContext, vm.go:40-58) → реализован wall-clock бюджет (дефолт 5ms, WithEvalTimeout). Это ограничивает время и, следовательно, пик аллокаций, но:

  • бюджет НЕ детерминирован (загруженная машина съедает бюджет быстрее — воспроизведено: concurrency-тест под -race ловил abort на 5ms при 8 горутинах; см. TestLuaConcurrentEvaluate, комментарий);
  • числовой бюджет инструкций без форка gopher-lua невозможен.

F2. .. string-bomb у Lua: аллокация не ограничена ничем, кроме времени​

Классическая бомба s = s .. s в цикле: ~40 итераций ≈ сотни инструкций — инструкция-бюджет её бы НЕ поймал и у Starlark эквивалент тоже. В gopher-lua оператор .. — opcode VM без хуков; перехват аллокаций невозможен без форка. Реализованные частичные меры: guarded string.rep / string.format / table.concat (кап 1MiB, lua.go:297), math.random удалён, CallStackSize=256 / фиксированный registry. Итог: пик аллокаций ≈ wall-clock × скорость memcpy (~10ГБ/с) → при 5ms это ~50-100MB транзиентно на запрос; при 1ms ~10-20MB. Тест TestLuaConcatBombDocumentsTransientAllocation.

F3. У Starlark ТОТ ЖЕ класс дыры, но позиционируемой как «один шаг»​

"a" * 10**9 в Starlark — ОДНА операция: step-limit считает её за 1 шаг, watchdog (thread.Cancel) срабатывает только МЕЖДУ шагами → пик аллокации ограничен операндом, а не бюджетом (TestStarlarkSingleOpAllocationBypassesBudgets — документировано тестом при бюджетах 10 шагов / 1ms). Для длинных циклов-компрехеншенов step-limit работает идеально (настоящий instruction-бюджет) и не зависит от загрузки машины — в отличие от Lua.

F4. pcall НЕ является escape-люком у Lua (проверено эмпирически)​

Гипотеза атаки while true do pcall(f) end — бесконечный ping-pong raise/catch, который не выпускает abort из Lua-барьера. Проверка на v1.1.2: не воспроизводится. Причина: basePCall (baselib.go:260) зовёт Go-сторонний L.PCall — abort ловится ровно один раз и возвращается в main-loop, где следующая проверка ctx.Done() raises УЖЕ вне любого Lua-барьера. Тест: TestLuaBudgetBounded (ping-pong вариант), fuzzy seeds.

F5. expr: безопасность композицией — неизвестные имена отклоняются на компиляции​

Typed env (expr.Env(Env{})) → os.Getenv, now, open, любые неизвестные идентификаторы — ОШИБКА КОМПИЛЯЦИИ (policy load), а не рантайм. Термнация гарантирована грамматикой (нет циклов/рекурсии). now отключён (expr.DisableBuiltin("now")). Из трёх движков expr — единственный с compile-time-отказом для всей поверхности I/O и с нулевой потребностью в бюджетах.

F6. Известные отклонения контракта​

  • all() на пустом наборе: контракт env.go — false; Lua/Starlark реализуют так; expr all() — vacuously true (покрыто тестом TestExprAllIsVacuousOnEmpty). Если expr победит — либо задокументировать отклонение, либо писать условия через count().
  • Пустые строки мета: Lua/Starlark отдают nil/None, expr — "".

3. Challenge-протокол: результаты​

3.1 DoS-фаззинг (go fuzz, 30s на движок, 2026-10-06, Apple M5 Max)​

таргетexecsскоростьcorpusкрахи/зависания
FuzzLuaCondition5 369 915до 180k/s7150
FuzzStarlarkCondition4 326 454до 53k/s*8920
FuzzExprCondition8 062 837до 276k/s1 3380

(*) starlark-воркер медленнее из-за тяжёлых seed'ов-компрехеншенов. Seed-корпус включает атаки: бесконечные циклы, рекурсия, строки-бомбы, os/loadstring/debug-побеги, pcall-петли, невалидные байты. Бюджеты срабатывают, время ответа ограничено (см. тесты BudgetBounded у всех трёх).

3.2 Sandbox-escape атаки (тест-кейсы на каждую; lua_test.go: TestLuaSandboxEscapeAttempts, starlark_test.go, expr_test.go)​

атакаluastarlarkexpr
os.execute / io.openнет os/io в env (глобус nil → error)нет predeclared → compile errorнет таких имён → compile error
loadstring/load/dofile/requireудалены из base → errorнеприменимо (нет в языке)неприменимо
debug.getupvalue / upvalue-манипуляцияdebug удалён → errorнеприменимонеприменимо
setmetatable + __index рекурсияsetmetatable удалён → errorметатаблиц недоступнынеприменимо
string.rep OOMcap 1MiB → errorоперанд-бомба: см. F3 (watchdog только между шагами)нет repeat-оператора → compile error
table.concat / format-бомбаcap 1MiB → error; format-width добивается самим gopher-luaнеприменимоbounded operand'ами
бесконечный whilectx-abort по 5ms (на каждой инструкции)while невозможен в expression-mode (resolver While=false)нет циклов в грамматике
рекурсияCallStackSize=256 → stack overflowрекурсия структурно невозможна (только lambda)невозможна
мутация envenv-таблицы пересоздаются, мутации не переживают evalfrozen-значения → errorснапшот-структуры, мутации не видны
global-загрязнение между evalresetGlobals (lua.go:364), тест TestLuaGlobalsDoNotLeakневозможно (expression не создаёт глобалы)невозможно
время/рандомmath.random удалён; os.clock недоступенв universe нет time/randomnow() отключён (compile error)
nondeterminism hash()n/ahash() детерминирован per-runn/a

Вывод: все три песочницы держат surface-атаки. Единственные РЕАЛЬНЫЕ дыры — аллокационные (F2/F3), у Lua и Starlark симметрично; expr аллокационно безопасен по построению.

3.3 Перф: типичное when («any high-severity finding?», env 5 findings + 2 steps + meta), 10k итераций, Apple M5 Max, без -race​

движокmean ns/opp50 ns/opp95 ns/opB/opallocs/op
lua14 2769 41730 29246 343235
starlark4 2773 4585 1257 512143
expr5442928331 2249

Критерий карточки p95 ≤ 50µs: выполняют ВСЕ ТРИ (lua — на грани: 30µs при 5ms-бюджете и пуле состояний; без пула было бы хуже на порядок). Компиляция once (cache hit, seam вызывает Compile на шаг): ~80-135ns у всех трёх (hash lookup). Full load-time compile (cache miss) существенно дороже, но это policy-load path, не request path. Относительно: expr ~8× быстрее starlark, ~26× быстрее lua; по аллокациям expr ~6-38× экономнее.

3.4 Maintenance-здоровье зависимостей (факты на 2026-10-06, GitHub API)​

gopher-luastarlark-goexpr
repogithub.com/yuin/gopher-luagithub.com/google/starlark-go (go.starlark.net)github.com/expr-lang/expr
последний релизv1.1.2, 2026-04-01тегов НЕТ вообще (pseudo-version pin)v1.17.8, 2026-02-14
последний коммит2026-04-01 (~6 мес. назад)2026-10-05 (сутки назад; iterator leak fix #664)2026-07-07 (~3 мес. назад)
open issues1068196
archivedнетнет (переехал bazelbuild → google org)нет
stars6 9862 7818 038
лицензияMITBSD-3MIT
bus factorнизкий (1 maintainer)средний (Google, но нет релизов)средний (активная org)

Примечания: starlark-go не имеет ни одного тега за всю историю — обновления только через pseudo-version; API стабильное (Bazel-контракт). govulncheck: 0 reachable уязвимостей во всех трёх (единственный module-level совет GO-2026-5932 — старый x/crypto/openpgp, не наш код, не наши три депа).

3.5 Читаемость аудита: одна и та же политика на трёх языках​

Условие: «маскировать, если найден национальный ИНН/СНИЛС у нетрастовой организации» (план §2.2):

-- lua: многословно, зато полный Lua; аудитеру нужны знания Lua-семантики
-- (truthiness, метатаблицы — последние вырезаны песочницей)
return findings.any(function(f)
return f.category == 'innsnils'
end) and meta.org ~= 'trusted-int'
# starlark: Python-подобный, лямбды компактны; знакомо любому Bazel-инженеру
findings.any(lambda f: f.category == 'innsnils') and meta.org != 'trusted-int'
// expr: самый короткий; capitalisation от Go-структуры; `#` — элемент
// итерации, надо знать соглашение
any(Findings, #.Category == 'innsnils') and Meta.Org != 'trusted-int'

Для аудитера, не программиста: expr читается проще всего (нет лямбд), starlark чуть многословнее, lua — самый шумный (function...end). Для сложных условий (многошаговая логика, локальные переменные) Lua выразительнее всех (полный язык), starlark ограничен expression'ами (компрехеншены + лямбды покрывают 90% случаев), expr — только выражения (иначе compile error).

3.6 Верификация контракта (все три движка, engines_test.go)​

  • компиляция once + кэш: TestCompileOnceCacheConsistency
  • регистрация "lua"|"starlark"|"expr" в ScriptRegistry, when_engine матчинг: TestEnginesContractThroughPipeline
  • незарегистрированный when_engine → policy LOAD error с именем движка
  • несколько движков → when_engine обязателен (ошибка перечисляет доступные): TestMultipleEnginesRequireWhenEngine
  • интеграция с Engine.Run: условия реально ветвят — ran/skipped-трейсы для всех трёх; verdict композиция (flag-эмиттер)
  • eval-ошибка → fail_closed (deny) + trace error с "when:" prefix: TestEnginesEvalErrorFailsClosed
  • конкурентность: 8×25 Compile+Evaluate под -race — чисто

4. Критерии и рекомендация спайка​

критерийluastarlarkexpr
p95 типичного when (≤50µs)30.3µs ⚠ на грани5.1µs ✅0.8µs ✅✅
DoS: останов цикловwall-clock (load-чувствителен)step-limit нативныйнет циклов
DoS: пиковые аллокациидыра (..), ~время×copy-rateдыра (один шаг), ограничено операндомбезопасен
escape-surfaceсамая большая (полный ЯП), закрыта вырезанием libc-подобных модулей + тестамималая (expression-only + frozen)минимальная (typed env, compile-time)
детерминизм для аудитахорошая (random/time вырезаны)отличная (по спеке)отличная (now отключён)
maintenancev1.1.2, 6мес тишины, 1 maintainer, нет хуков в VMактивный (Google), но нет тегов вообщеактивный, релизы регулярные
читаемость аудита3/54/55/5 (типичные when)
выразительность сложных условий5/5 (полный язык)4/52/5 (только выражения)
правки против owner-плананужен форк для instruction-бюджетабез правокбез правок

Рекомендация спайка (не решение): против owner-кандидата говорит комбинация F1+F2 (нет instruction-бюджета; аллокации не ограничены) при p95, стоящем в 26 раз хуже expr, при худшей читаемости и худшем maintenance (тишина 6 месяцев, один мейнтейнер, форк нужен для полного бюджета). ЗА владельца: Lua самый выразительный (сложные условия, многошаговые сценарии) и кандидат «проработан» глубже всех в этом спайке.

Практичная композиция, которую данные спайка поддерживают:

  1. expr как дефолтный when_engine для прод-политик (перф, песочница по построению, читаемость) — условия типичных when-политик выражаются им полностью (план §2.2 примеры — все выражения).
  2. starlark вторым, если появятся условия со сложной логикой, где нужны лямбды/компрехеншены, но не полный язык (нативный step-limit — лучший budget-механизм из трёх).
  3. lua оставить зарегистрированным, НО не дефолтным: использовать для условий, где нужна полная выразительность; принимать F2 (аллокационная дыра) осознанно с tight-бюджетом (1-2ms) и, при росте трафика, — форк gopher-lua с аллокационным капом или вынос Lua-оценок в отдельный процесс-пул.

Альтернатива, если owner настаивает на Lua-дефолте: обязательные компенсаторы — tight wall-clock (≤2ms), процес-level debug.SetMemoryLimit как backstop, лимит одновременных Lua-оценок (semaphore), мониторинг p99.

5. Что именно решает owner​

  1. Дефолтный when_engine для прод-политик (expr / starlark / lua) — данные в §3.3-3.5, находки F1-F5.
  2. Принять ли аллокационные дыры F2 (lua) / F3 (starlark) как known-risk с компенсаторами (tight-бюджеты + SetMemoryLimit + concurrency-лимиты) или требовать форк/процесс-изоляцию.
  3. Судьбу all()-расхождения (F6): задокументировать или выровнять.
  4. Нужен ли lua в прод-реестре вообще, или only expr+starlark, а Lua — за feature-flag.
  5. Числа бюджетов по умолчанию (сейчас: lua 5ms/1MiB, starlark 100k шагов/ 25ms, expr — нет) — уточнить по прод-профилю OP-23.

6. Риски принятия результатов​

  • Бенчмарк на Apple M5 Max (darwin/arm64), без -race; прод-профиль (linux, под нагрузкой, c GC-давлением) даст другие абсолютные числа — отношения (26×/8×) устойчивее абсолютов. Повторить на стенде OP-23.
  • Wall-clock бюджеты Lua load-чувствительны (F1) — при решении «lua-дефолт» это главный операционный риск (ложные abort'ы под нагрузкой → fail_closed deny валидного трафика).
  • Спайк не покрывал: Long tail сложных политик (выразительность проверялась вручную), взаимодействие с OP-8 middleware (per-request budget-семантика), атаки на сами env-билдеры через аномальные Meta (labels с нулевыми байтами и т.п. — базово покрыто фаззингом источников, но не env).