The Daily Newsstand · Free, Always
Sunday, November 22, 2026

HR мёртв или то, как я писал ZK-верификаторы на Fe

Translate

Начну с простого и наболевшего. Я безработный кодер) Рынок сейчас — дно тотальное. Три месяца я рассылаю отклики, и вот срез моей истории:

Вакансия

Итог

AppSec-инженер в крупном банке

отказ

AppSec-инженер в бигтехе

отказ

AppSec-инженер, ещё один

висит «отклик отправлен», как мемориал

Offensive AppSec Engineer

отказ. Похоже, я недостаточно offensive

Rust Developer

отказ

Senior Backend (Rust/C++)

тишина, как в неких датацентрах

Backend Middle

отказ. Для мидла я, видимо, слишком недомидленный

Вайб-кодер / AI-разработчик

отказ. Меня не взяли вайб-кодером. Вайб не тот

Пентестер

и тут тишина

Тестировщик ПО

тишина. Хотя тестировщиком в VK я уже поработал

Техподдержка хостинга, 2-я линия, тикеты

«позиция уже закрыта». Даже тикеты разобрали без меня

Quant PM, трейдер проп-деска, арбитраж трафика

тишина.

Вишенка на торте: между отказами на вакансии специалиста по информационной безопасности красная площадка заботливо подсунула мне курсы «Специалист по информационной безопасности». Это не баг, это их бизнес-модель. Рынок труда давно превратился в воронку продаж: тебя не берут на работу, чтобы продать тебе обучение для работы, на которую тебя не возьмут.

Схема простая и циничная до слёз. Живого человека, который находит дыры в продакшне и пишет об этом публично, вежливо отшивают шаблонным «к сожалению». Зато ему же за 150 тысяч в рассрочку предлагают стать «Топовым АппСек Инженером с нуля за 6 месяцев»… С гарантией трудоустройства, напечатанной таким мелким шрифтом, что для её прочтения нужен отдельный курс, и с наставником, чей боевой опыт — три вебинара и CTF для школьников.

Так что, видимо, реальному специалисту надо купить ещё 100500 курсов. «Хакер PRO». «Пентест с нуля до оффера». «AppSec Senior за 3 месяца». «Этичный хакинг для чайников». «DevSecOps Мастер-Класс». И сверху «Нейросети для безопасника», потому что без слова «нейросети» резюме сейчас видимо не открывают. Все сертификаты — в шапку резюме, жирным. HR-фильтр ищет ключевые слова, а не человека, который отличает SQL-инъекцию от SQL-запроса. Его этому не учили, у него тоже был курс.

Саму вакансию AppSec в итоге получит выпускник интенсива, который на собеседовании без запинки отбарабанит OWASP Top 10 и ни разу в жизни не открывал чужой код. Через полгода он пропустит в прод ровно тот баг, про который был слайд номер пять. Его компания потеряет данные клиентов. А чудо-курсы сделают из этого кейс и продадут новый поток.

Ну и как же без процветания ИИ-слопа. Резюме теперь читает не человек, а ИИ-HR. Он сверяет твой текст с вакансией, которую тоже написал ИИ, и отказ тебе пишет тоже ИИ: «Мы внимательно изучили ваш опыт». Никто ничего не изучал. Три нейросети поговорили между собой, организовали консенсус и решили, что ты не подходишь. Сопроводительные письма генерирует ChatGPT, тестовые задания решает Claude, собеседование ведёт бот, а на выходе нанимают того, у кого промпт лучше.

А когда поздно, выходит новость: «Ой. У нас утекла пара ТБ данных». Причём утекла она не из-за гениальной APT-группировки с бюджетом маленькой страны. Её вынес школьник с агентами Клода, который за вечер, между домашкой по алгебре и катками, прогнал по вашему API всё, что не закрыли выпускники курсов. Атакующим ИИ дал скорость. Защищающимся он дал красивый PDF-отчёт с зелёными галочками, который никто не открывал, ведь если отчет есть — он точно хороший.

Мой любимый жанр данного цирка — компании, которые годами рассказывают на конференциях, какая у них крутая инфраструктура. Есть, например, одна сеть пиццерий, думаю вы слышали о ней. Пицца у них правда вкусная, без шуток, я её часто ем. И ещё они очень любят рассказывать, что они не пиццерия, а крутая IT-компания, которая печёт пиццу: своя платформа, микросервисы, доклады, митапы, мерч. А потом — бам, и база клиентов гуляет по дарку: имена, телефоны, адреса доставки. IT-компания, которая случайно печёт пиццу, оказалась пиццерией, которая случайно хранит ваши данные. Пицца, к слову, осталась качественной. Качество — единственное, что у них в тот день не утекло.

Нанимать людей, которые умеют находить такое руками, наверно было дорого и долго. Утечка, как обычно бывает, вышла дороже.

Чтобы без двойных стандартов: я тоже иногда пишу с ИИ, и в fe-zk это честно раскрыто в docs/AI_LOG.md. Разница в одном: каждую строку я вручную проверяю тестом на векторах независимых эталонов и могу объяснить. ИИ — это инструмент (множитель), а не замена человеку, который понимает, что делает. Именно такого человека вы и отсеиваете своим ИИ-HR.

Вывод простой: никуда ты не нахантишься, друг мой, если ты, конечно, не доктор наук по информатике с пятью сертификатами и рекомендацией от ИИ-HR ;)

Почему с безопасностью всё так грустно: верификаторы без проверок, мосты без валидации, функции без проверки длины ответа. Ответ рядом: людей, которые умеют это проверять, отсеивают на этапе «у вас нет 5 лет опыта в нашем внутреннем NDA фреймворке». Ладно) Раз меня не берут чинить чужой код, я написал свой, и такой, чтобы целый класс этих багов ловил компилятор. Получилось вот что.

Меня зовут 0xItsss, я пишу на Rust и состою в исследовательском коллективе ZKRP. Мы занимаемся zero-knowledge криптографией, приватной инфраструктурой и децентрализованными системами. Почти год мы с командой делали OrangeHail — платёжную инфраструктуру на ZK. Про сам проект здесь говорить не буду, да и он пока не опен-сорснут. Скажу одно: за этот год я насмотрелся на то, как ломаются ончейн верификаторы и оффчейн SDK. Почти всегда виноваты не формулы, а проверки, которые забыли правильно реализовать.

Когда объявили Fe Builders Challenge 2026, я решил закрыть дыру, которая давно бросалась в глаза. В языке Fe нет ни одного верификатора доказательств. Любой ZK-проект на Fe вынужден уходить обратно в Solidity, потому что snarkjs, gnark и snark-verifier экспортируют только Solidity.

За пару недель размышлений и 5 дней кодинга получилась fe-zk. Это библиотека и генератор:

  • верификаторы Groth16, PLONK (snarkjs и gnark), halo2-KZG (SHPLONK и GWC), KZG-открытия и FRI/STARK для пруфов Plonky3;

  • слой полей, кривых и хешей за трейтами Fe;

  • fe-zk-gen на Rust, который из verifying key делает Fe-контракт с тестами;

  • демо: Semaphore v4, верификатор Tornado Cash на реальных mainnet-пруфах, zk Game of Life.

Ниже — как это устроено, где было больно и почему Fe мне понравился больше, чем я ожидал.

Введение в ZK для тех, кто не в теме

Zero-knowledge доказательство — это способ убедить другого, что утверждение верно, не раскрывая, почему оно верно. Классический пример: «я знаю секрет, хеш которого лежит в этом дереве», и при этом не показывать ни секрет, ни позицию в дереве.

В блокчейне ZK нужен для двух вещей:

  • Приватность. Доказать, что ты член группы, имеешь право на выплату или не тратишь монету дважды, не раскрывая, кто ты. Так работают Semaphore, Tornado Cash и Zcash.

  • Масштабирование. Посчитать что-то тяжёлое вне чейна и проверить на чейне короткий пруф, а не повторять вычисление. Так работают zk-роллапы.

Три роли

Три роли: setup, prover, verifier

Три роли: setup, prover, verifier

Три роли: setup, prover, verifier

  • Схема (circuit) описывает утверждение как систему уравнений над конечным полем. Например, «Poseidon(secret) — лист дерева с корнем root».

  • Prover знает секрет (witness) и делает пруф. Это тяжело: секунды или минуты на GPU/CPU.

  • Verifier получает пруф, публичные входы и verifying key, и отвечает «да» или «нет». Это дёшево: миллисекунды и сотни тысяч газа.

fe-zk — это именно verifier. Пруфы делают внешние тулзы, а мы проверяем их на чейне. Поэтому верификатор и есть граница доверия: если он ошибся, контракт поверит поддельному пруфу.

Свойства, которые нельзя сломать

  • Completeness: честный пруф всегда принимается.

  • Soundness: без знания witness нельзя сделать пруф, который примут.

  • Zero-knowledge: пруф ничего не говорит о witness.

Верификатор отвечает за первые два. Почти все реальные взломы ZK-систем — это soundness-баги именно в верификаторе, а не в математике.

SNARKи и STARKи

SNARK (Groth16, PLONK, halo2-KZG)

STARK (FRI, Plonky3)

Криптография

эллиптические кривые, спаривания

только хеши

Setup

доверенная церемония (powers of tau)

прозрачный, без церемонии

Размер пруфа

128 байт – пара KB

десятки KB

Газ проверки

200k–400k

миллионы

Постквантовость

нет

да (хеши)

Поле

BN254, 254 бита

KoalaBear/BabyBear, 31 бит

SNARK дешёвый на EVM, потому что у Ethereum есть precompile для кривой BN254: сложение (0x06), умножение (0x07) и спаривание (0x08). STARK дорогой, потому что precompile для его полей и хешей нет, всё считается опкодами ВМ.

Спаривание за одну минуту

Спаривание (pairing) — это функция e(P, Q), которая берёт точку из группы G1 и точку из G2 и выдаёт элемент третьей группы. Главное свойство — билинейность:

e(a·P, b·Q) = e(P, Q)^(a·b)

Это позволяет проверить равенство «произведений скрытых чисел», не зная самих чисел. Groth16 сводит всю проверку к одному уравнению из четырёх спариваний, и precompile 0x08 проверяет его одним вызовом.

KZG-коммитменты

PLONK и halo2 строятся на KZG. Prover коммитит многочлен f(X) одной точкой кривой [f(τ)], где τ — секрет церемонии, который никто не знает. Потом он открывает многочлен в любой точке z: показывает y = f(z) и короткое доказательство. Верификатор проверяет открытие одним спариванием. Вся PLONK-проверка — это «многочлены схемы удовлетворяют уравнениям в случайной точке», и эта точка берётся из транскрипта.

Fiat–Shamir

Интерактивный протокол — это когда верификатор шлёт случайные челленджи. На чейне диалога нет. Поэтому челленджи считаются как хеш от всего, что prover уже прислал. Если в хеш не попало что-то важное, prover может подобрать это «что-то» под уже известный челлендж и подделать пруф. Это и есть уязвимость Frozen Heart, о ней ниже.

Какие системы и библиотеки поддерживает fe-zk

Каждая система доказательств — это своя экосистема тулзов. Верификатор на чейне должен совпадать с тулзой бит в бит: формат ключа, порядок координат, транскрипт.

circom + snarkjs

circom — DSL для описания схем, де-факто стандарт в Ethereum-ZK. snarkjs — JS-библиотека от iden3, которая из схемы circom делает ключи и пруфы Groth16 и PLONK, а также экспортирует Solidity-верификатор.

В fe-zk: fe-zk-gen groth16 --snarkjs vk.json и fe-zk-gen plonk. Подвох snarkjs: в JSON-пруфе координаты G2 идут в одном порядке, а в Solidity calldata — в переставленном. Сгенерированный контракт переставляет их обратно, и это покрыто тестом.

arkworks

arkworks — набор Rust-крейтов для ZK: поля, кривые, Groth16. Используется в куче проектов как эталон. Его формат ключа отличается от snarkjs сериализацией.

В fe-zk: fe-zk-gen groth16 --arkworks. Сам генератор проверяет ключи через ark-bn254, то есть arkworks у нас ещё и независимый валидатор.

gnark

gnark — Go-библиотека от Consensys, одна из самых быстрых. Её PLONK отличается от snarkjs: транскрипт на SHA-256 с текстовыми метками ("gamma", "beta", "alpha", "zeta"), другой порядок абсорбции и опциональные BSB22-коммитменты. Это расширение, которое позволяет схеме коммитить промежуточные значения.

В fe-zk: fe-zk-gen gnark, ABI Verify(bytes,uint256[]), совместимый с Solidity-верификатором самого gnark. Адаптер verify_calldata отклоняет пруф и входы любой длины, кроме той, что задана ключом.

halo2 (PSE)

halo2 изначально сделан Zcash на кривых Pasta с IPA. Форк PSE (Privacy & Scaling Explorations) перевёл его на BN254 и KZG, чтобы проверять на EVM. Схемы halo2 — это PLONKish-таблицы с кастомными гейтами и lookup-аргументами. snark-verifier генерирует для них Solidity.

Открытия многочленов в halo2-KZG бывают двух видов:

  • GWC (Gabizon–Williamson–Ciobotaru): по одному открытию на точку, проще;

  • SHPLONK: все точки батчатся в одно открытие, дешевле по газу.

В fe-zk поддержаны оба: fe-zk-gen halo2. Метаданные схемы извлекаются так же, как это делает snark-verifier.

KZG и EIP-4844

Отдельный модуль kzg проверяет одиночные и батч-открытия (GWC и SHPLONK, 162,122 газа для SHPLONK). Там же лежит обёртка над precompile 0x0a из EIP-4844, через который проверяют блобы Ethereum. Его формат входа строгий: 192 байта, версионный хеш в начале. Обёртка проверяет и длину, и магическую константу ответа.

Plonky3

Plonky3 — Rust-тулкит от Polygon для STARK на маленьких полях (KoalaBear, BabyBear, Mersenne31). Схемы там описываются как AIR (Algebraic Intermediate Representation): таблица трейса и полиномиальные ограничения между соседними строками. Коммитменты — Merkle-деревья, проверка низкой степени — FRI.

В fe-zk: verify<A: Air> для uni-stark на KoalaBear, Ext4 и Keccak-Merkle. Подробности ниже.

Semaphore

Semaphore — протокол анонимного членства от PSE поверх circom и Groth16. Пользователь доказывает «я в группе» и публикует nullifier, чтобы не проголосовать дважды. Группа хранится в LeanIMT — инкрементальном Merkle-дереве на Poseidon.

В fe-zk: ингот fe_zk_semaphore с ключами публичной церемонии глубин 1…10 и кит fe_zk::anon: LeanImt, корни которого совпадают с @semaphore-protocol/group 4.x, и Nullifiers.

BLS12-381

Вторая популярная кривая, на ней Ethereum consensus и Zcash. EIP-2537 добавил для неё precompile 0x0b–0x11 в Prague. В fe-zk лежат проверенные обёртки над ними.

Где на самом деле ломаются верификаторы

Математика Groth16 занимает одну строку:

e(-A, B) · e(α, β) · e(vk_x, γ) · e(C, δ) == 1,   vk_x = IC₀ + Σ xᵢ·ICᵢ

Реализацию проверяют аудиторы, тесты проходят, а через полгода выясняется, что:

  1. Публичный вход не проверен на < r. x и x + r дают одну и ту же точку xᵢ·ICᵢ. Если x — nullifier, получаем двойную трату.

  2. Точка не проверена на кривой. Precompile ecAdd отклонит мусор, но не все пути до него доходят. А для G2 нужна ещё и отдельная проверка подгруппы.

  3. Транскрипт Fiat–Shamir не включает какой-то вход. Это как раз класс Frozen Heart: челлендж не зависит от входа, и пруф подделывается.

  4. Результат precompile не проверен по длине. Вызов адреса без кода возвращает success и пустой ответ. Читаем нули и считаем, что спаривание прошло.

  5. Нехватка газа выглядит как невалидный пруф. Атакующий подрезает газ, precompile падает, верификатор отвечает false на честный пруф.

В Solidity каждое из этих правил — соглашение. uint256 остаётся uint256, и ничто не мешает передать непроверенное значение туда, где нужен элемент поля. Защищают только ревью и дисциплина.

Моя главная идея: превратить правила в свойства типов, чтобы нарушение было ошибкой компиляции, а не находкой аудитора.

Коротко про язык Fe

Fe — язык смарт-контрактов под EVM. Синтаксис похож на Rust, но язык свой. Для нас важно, что в нём есть:

  • трейты с ассоциированными константами;

  • дженерики и const generics, в том числе по u256;

  • const fn и static_assert, которые исполняются в компиляторе;

  • приватные поля структур;

  • эффекты uses (...): функция объявляет, к чему у неё есть доступ (storage, вызовы, контекст);

  • бэкенды Sonatina и Yul.

Компилятор написан на Rust. Я собирал Fe 26.5.0 из исходников для теста покрытия разных CPU через Proxmox. Пребилд не встал на ВМ с отключенной AVX-инструкцией.

Архитектура

Архитектура fe-zk

Архитектура fe-zk

Архитектура fe-zk

Пойдём снизу вверх.

Слой 1: одно поле на всех

Трейт Field из src/field.fe:

pub trait Field {
    const MODULUS: u256

    fn zero() -> Self
    fn one() -> Self
    fn is_canonical(_ v: u256) -> bool
    /// The element `v`, or `None` if `v` is not canonical. Use this for untrusted input.
    fn from_canonical(_ v: u256) -> Option<Self>
    /// `v mod MODULUS`. Silent reduction: never use it on untrusted input.
    fn reduce(_ v: u256) -> Self
    fn add(self, _ other: Self) -> Self
    fn mul(self, _ other: Self) -> Self
    fn inv(self) -> Option<Self>
    // ...
}

Реализация одна: impl<const P: u256> Field for Fp<P>. Модуль — параметр типа, поэтому Fp<BN254_R>, Fp<KOALABEAR_P> и Fp<GOLDILOCKS_P> — разные типы. Перепутать элементы двух полей нельзя, это ошибка типов.

Montgomery-форма не нужна. addmod и mulmod в EVM работают с 512-битными промежуточными значениями и стоят по 8 газа. Один и тот же код корректен и для 254-битных полей BN254, и для 31-битного KoalaBear.

Поверх Field написаны хеши. Poseidon2 существует в одном экземпляре:

fn permute_generic<F: Field + Copy, const T: usize, const NE: usize, const NI: usize>(...)

Это и BN254 с t = 3, и KoalaBear с t = 16 под константы Plonky3. Merkle-путь дженерик и по хешу, и по типу узла: merkle_root<H: Compression<D>, D: Copy, const N: usize>. Fe мономорфизирует дженерики, поэтому абстракция ничего не стоит в самом рантайме.

Векторы для хешей взяты из circomlibjs, Plonky3 и HorizenLabs.

Слой 2: непроверенную точку нельзя создать

У Fp, G1 и G2 приватные поля. Снаружи модуля есть только два входа: from_canonical / from_coords, которые возвращают Option, и явный reduce для констант и выходов хешей. Отдельная проба подтверждает, что компилятор отклоняет Fr { v: 100 }.

С G2 всё тоньше. Проверка подгруппы G2 на EVM стоит около 750k газа. Precompile спаривания из EIP-197 и так её выполняет. Тратить газ дважды глупо, но и оставлять «полупроверенную» точку в общем типе опасно. Поэтому точка G2 из пруфа получает отдельный тип G2Proof:

Путь данных из calldata до спаривания

Путь данных из calldata до спаривания

Путь данных из calldata до спаривания

У G2Proof нет конверсии в G2 и нет групповых операций. Потребить его можно только в pairing_check_proof / pairing_try_proof, то есть там, где precompile досмотрит подгруппу. Тест с точкой на твисте вне подгруппы (вектор из py_ecc) подтверждает, что пруф отклоняется.

Слой 3: precompile и правило отказа

Каждый вызов precompile проверяет три вещи: флаг успеха, длину ответа и точное значение. Для спаривания ответ должен быть ровно 1, а не «не ноль».

// src/ec/precompile.fe
if r.success() {
    assert(r.returndata_len() == out_len)
}
r.success()

Перед каждым вызовом верификатор проверяет остаток газа:

pub fn require_gas(_ cap: u256) uses (ctx: Ctx) {
    assert(ctx.gas() >= cap + GAS_MARGIN)
}

Каждый вызов precompile: газ, флаг, длина, значение

Отсюда правило отказа: невалидный пруф — это false, нехватка газа — revert. Подрезанный газ больше не превращает честный пруф в невалидный.

Сигнатура uses (call: Call, ctx: Ctx) здесь не для красоты. Верификатор может делать static call и читать газ, но не может писать в storage и слать value. Проверяет компилятор: без эффекта storage функция физически не тронет хранилище.

Groth16 целиком

Ядро верификатора короче, чем объяснение к нему:

pub fn verify<const N: usize>(_ vk: Vk<N>, _ proof: Proof, _ inputs: [Bn254Fr; N]) -> bool
uses (call: Call, ctx: Ctx)
{
    if !vk.usable { return false }
    var vk_x = vk.ic0
    var i: usize = 0
    while i < N {
        vk_x = g1_add(vk_x, g1_mul(vk.ic[i], inputs[i]))
        i += 1
    }
    pairing_try_proof(
        [proof.a.neg(), vk.alpha, vk_x, proof.c],
        [
            proof.b,
            G2Proof::from_g2(vk.beta),
            G2Proof::from_g2(vk.gamma),
            G2Proof::from_g2(vk.delta),
        ],
    )
}

Обратите внимание на типы:

  • inputs: [Bn254Fr; N] — неканонический вход сюда не попадёт, он отсеян в verify_calldata через from_canonical;

  • N — const generic: длина входов зашита в тип ключа, дописать или выкинуть публичный вход нельзя;

  • proof.b уже G2Proof, ключевые точки поднимаются в G2Proof явно.

Semaphore поддерживает глубины дерева от 1 до 10, у ключей разное число входов. Обслуживает их одна функция verify_with<const N: usize>.

Отдельный момент: Groth16 malleable. Из валидного пруфа можно сделать другой валидный. Поэтому в примерах пруф и его хеш никогда не используются как nullifier, это прописано в SAFETY.md.

Генератор и ключ, который проверяет компилятор

fe-zk-gen читает ключ snarkjs, arkworks, gnark или halo2, проверяет его через ark-bn254 и эмитит Fe-ингот. Флага «пропустить проверки» нет — генератор просто откажется.

Конвейер генератора

Конвейер генератора

Конвейер fe-zk-gen: ключ проверяется дважды, генератором и компилятором

Самое интересное начинается дальше. Функция валидности точки в Fe — const fn, поэтому сгенерированный контракт перепроверяет свой ключ на этапе компиляции:

// Verifying key, validated by fe-zk-gen and re-validated at compile time.
static_assert(g1_is_valid(ALPHA_X, ALPHA_Y))
static_assert(!VK_ALPHA.is_infinity())
static_assert(g2_is_valid(BETA_X0, BETA_X1, BETA_Y0, BETA_Y1))
static_assert(!VK_BETA.is_infinity())

const VK_ALPHA: G1 = G1::from_coords_or_infinity(ALPHA_X, ALPHA_Y)
const VK_BETA: G2 = G2::from_coords_or_infinity(BETA_X0, BETA_X1, BETA_Y0, BETA_Y1)

Внутри g2_is_valid — проверка подгруппы G2, цикл из 254 итераций mulmod. Он исполняется в компиляторе. Если кто-то руками поправит одну константу ключа, сборка упадёт:

error[8-0081]: static assertion failed

Это закреплено тестом генератора corrupted_key_constant_fails_to_compile.

Вторая защита — from_coords_or_infinity. Для невалидной точки она даёт бесконечность, а ключ с бесконечностью в α, β, γ или δ помечен как непригодный, и verify возвращает false. Даже если удалить static_assert, непроверенная точка в ключе не появится.

Эффект на газ оказался приятным бонусом. Ключ теперь — набор констант, которые в рантайме стоят по 2 газа. Построение ключа PLONK подешевело с 1.05M газа до 673, vk() у halo2 — с 1.51M до 1.3k. Цена — около 20 секунд компиляции на три проверки подгруппы G2.

И главное: это та же самая функция, что проверяет точки из calldata в рантайме. Определение валидности существует в одном месте.

Вместе с контрактом генератор эмитит тесты: один валидный пруф и батарею невалидных — подменённый элемент, вход ≥ r, координата ≥ q, точка вне кривой, точка G2 вне подгруппы, переставленные входы. Каждое правило безопасности имеет тест, который падает без этого правила.

PLONK и транскрипт

В PLONK самое опасное — транскрипт Fiat–Shamir. Порядок абсорбции должен совпадать с эталонным верификатором байт в байт, и в него должно входить всё: digest ключа, все публичные входы, все коммитменты.

Для snarkjs и gnark транскрипты разные. gnark использует SHA-256 с доменными метками и опциональные BSB22-коммитменты, snarkjs — Keccak. Я переносил их построчно и для каждого написал тест: изменение любого входа транскрипта меняет челлендж. Это прямая защита от Frozen Heart.

Самый дорогой элемент PLONK — инверсии в поле. Возведение в степень r - 2 циклом стоит около 25k газа. Через precompile modexp (0x05) — около 1.4k:

/// `1 / a` in the BN254 scalar field through the modexp precompile (0x05).
/// Success flag, returned length (32) and canonical result are checked (rule 6).
pub fn inv_modexp(_ a: Bn254Fr) -> Option<Bn254Fr> uses (call: Call, ctx: Ctx)

Эта функция общая для PLONK, gnark и KZG. После этой и ещё пары оптимизаций газ относительно Solidity-верификаторов тех же тулов на одном пруфе:

Верификатор

Fe / Solidity

Groth16 (snarkjs)

1.02–1.03x

PLONK (snarkjs)

1.05x

PLONK (gnark)

1.10–1.11x

halo2-KZG

1.17x

Почти паритет. При этом в Fe-версии больше проверок, чем в эталонном Solidity.

FRI/STARK: самое тяжёлое

Верификатор для пруфов Plonky3 uni-stark: поле KoalaBear, расширение степени 4, Merkle-коммитменты на Keccak, arity 2. Готового EVM-верификатора пруфов Plonky3 я не нашёл ни на одном языке.

Проверка STARK-пруфа: ограничения AIR в точке ζ и FRI

Сначала верификатор умел только Fibonacci. Потом я вынес AIR в трейт, и верификатор стал verify<A: Air>. AIR на Fe переписывается с Rust-версии Plonky3 построчно:

impl Air for FibonacciAir {
    const WIDTH: u256 = 2
    const NUM_PUBLIC: u256 = 3
    const MAX_DEGREE: u256 = 2

    fn eval(_ ctx: AirCtx) -> E {
        let l0 = ctx.local[0]
        let l1 = ctx.local[1]
        let n0 = ctx.next[0]
        let n1 = ctx.next[1]
        var acc = E::zero()
        acc = ctx.assert_first(acc, l0.sub(ctx.public_value(0)))
        acc = ctx.assert_first(acc, l1.sub(ctx.public_value(1)))
        acc = ctx.assert_transition(acc, l1.sub(n0))
        acc = ctx.assert_transition(acc, l0.add(l1).sub(n1))
        ctx.assert_last(acc, l1.sub(ctx.public_value(2)))
    }
}

assert_transition и прочие делают ровно то, что VerifierConstraintFolder в Plonky3: acc = acc · α + selector · constraint. Второй AIR, MulAir на 6 колонок, проходит тот же набор тестов. Пруфы для обоих сделаны настоящим Plonky3 0.4.2.

Ограничения я сделал явными. Поддерживается одна quotient-чанка, то есть ограничения степени не выше 2. AIR с MAX_DEGREE > 2 верификатор отклоняет, а не проверяет неправильно.

Как я снял 70 % газа

Первая рабочая версия стоила 4.67M газа исполнения. Профилирование показало, что дорогая не криптография, а скрытые расходы компилятора:

  • Struct с inline-массивами копируется на каждом вызове. Передача по значению — это копия всех полей. Решение: поля MemArray.

  • Индексация MemArray стоит около 100 газа. Там bounds check и checked-умножение. Решение: одна проверка диапазона, потом offset_bytes(ptr, i * 32) под #[arithmetic(unchecked)].

  • Циклы не разворачиваются. 100–400 газа на итерацию при -O1. Горячие места я развернул вручную.

Итог — 1.41M газа исполнения на пруфе Fibonacci (2^10 строк, 100 бит conjectured security), полная транзакция — 2.86M. Контракт весит 12.9 KB. Для STARK на EVM это нормально, хотя Groth16 всё равно дешевле в разы. Цифры честно лежат в docs/GAS.md вместе с командой, которая их считает.

Как я проверял

Правило одно: векторы только из независимых эталонов, никогда из собственного кода.

Компонент

Эталон

Poseidon

circomlibjs

Poseidon2

Plonky3, HorizenLabs

Groth16

snarkjs, arkworks

PLONK

snarkjs, gnark

halo2-KZG

PSE halo2

FRI/STARK

Plonky3 0.4.2

G2 вне подгруппы

py_ecc

Скрипты, которые генерируют векторы, лежат в репозитории вместе с версиями тулов. Церемониальный материал — настоящий PSE Perpetual Powers of Tau, скачивается по закреплённому хешу.

Поверх этого есть дифференциальный тест: один и тот же набор пруфов, валидных и испорченных, гоняется через наш верификатор и через эталонный. Ответы должны совпасть все.

На реальных данных:

  • Semaphore v4: ключи публичной церемонии для глубин 1…10, пруфы из официального SDK. Результаты сверены с SemaphoreVerifier.sol самого Semaphore.

  • Tornado Cash: верификатор withdraw принимает настоящие пруфы с mainnet. Это только верификатор, миксера в репозитории нет.

  • zk Game of Life: поле 16×16 упаковано в биты u256, шаг на чейне делается побитовыми сумматорами без цикла по клеткам. Отдельно Groth16-пруф 512 поколений. Один шаг на чейне стоит 657 газа. Проверка пруфа 512 поколений — 208,210 газа против 271,686 газа за прогон тех же 512 шагов на чейне.

Итого 493 теста на Fe, CI в четыре джобы. Все правила безопасности сведены в docs/SAFETY.md: правило, файл и строка, где оно применяется, и тест, который без него падает.

Что я нашёл в самом Fe

Криптография быстро упирается в края компилятора. Я записал около десятка проблем и отправил в апстрим 3 PR и 2 issue:

  • #2061 — обёртки precompile с фиксированным выводом в std::evm::crypto возвращали Ok с нулями, если precompile отсутствует. Для криптографии это ровно пункт 4 из начала статьи.

  • #2062 — парсер принимал var s: u256 = a и блок на следующей строке за struct literal a { ... }.

  • #2063 — fe fmt переносил хвостовой комментарий внутрь списка аргументов.

  • #2064 — нет raw staticcall со статическим буфером, теряем около 200 газа на каждый вызов precompile.

  • #2065 — в const-контексте нельзя assert и методы Option.

Каждый PR идёт с регрессионным тестом и проходит тесты Fe.

Мелочи, о которые спотыкаешься: allow_unsafe = true нужно ставить у зависимого ингота; абсолютные пути зависимостей не работают; оптимизатор выкидывает неиспользуемые результаты, поэтому замеры газа надо отдавать в event.

Почему Fe крутой

Не из-за синтаксиса. Fe позволяет перенести правила безопасности из ревью в компилятор:

Правило

Solidity

Fe

вход < r

require в каждом месте

from_canonical → Option, иначе не создать

точка на кривой

конвенция

приватные поля, только проверяющий конструктор

G2 только в спаривание

комментарий

тип G2Proof без арифметики

ключ валиден

надежда и аудит

const fn + static_assert, иначе не компилируется

число входов

проверка длины

Vk<const N>, [u256; N]

верификатор чистый

view

uses (call, ctx), без storage

один хеш на все поля

копипаста

permute_generic<F: Field, ...>

В Solidity каждая строка левой колонки — дисциплина. В Fe это ошибка компиляции. И всё это почти без потерь в газе: Groth16 медленнее эталона на 2–3 %.

Что приятно удивило: ассоциированные константы в трейтах, const generics по u256, const fn, которая честно гоняет 254 итерации mulmod в компиляторе, и проверка эффектов. Что пока сыро: оптимизатор (не разворачивает циклы, дорогая индексация) и мелкие баги парсера и форматтера. Половину из них я уже отправил апстрим.

Ограничения

Не успел следующее:

  • Аудита нет. Это исследовательский код, без аудита в проде не используйте, как и сам Fe.

  • FRI привязан к одному конфигу Plonky3: KoalaBear, Keccak-Merkle, арность 2, ограничения степени до 2.

  • Рекурсии нет.

  • halo2 дороже эталона на 17 %, есть куда оптимизировать.

Что дальше

Код открыт под Apache-2.0: github.com/0xitsss/fe-zk. Начать можно с scripts/demo.sh и таблицы «For judges: one screen» в README.

В планах Poseidon2-Merkle для FRI, больше конфигов Plonky3, quotient из нескольких чанков и поддержка библиотеки, если сообществу Fe она окажется нужна. Если хотите в будущем писать на Fe и вам нужна проверка ZK-пруфов — приходите ко мне в issues, разберёмся и поработаем вместе.

View the original on Хабр →

KioskNews shows a cleaned-up reading view extracted from the publisher’s page — the original always lives on their site, not ours.