Этот контракт SecureLottery использует Chainlink VRF для генерации действительно случайного числа. Функция requestRandomWords запрашивает случайное число у службы Chainlink VRF. Функция fulfillRandomWords (которая ДОЛЖНА присутствовать при наследовании от VRFConsumerBaseV2Plus) получает случайное число и использует его для определения победителя. Это обеспечивает справедливый и непредсказуемый результат лотереи.

Использование Chainlink VRF влечет за собой внешние зависимости и затраты на газ. Кроме того, требуется настроить подписку на Chainlink VRF и управлять связанными с ней сборами. Однако эти затраты часто являются оправданной платой за повышенную безопасность и справедливость.

#miner #mev

Атака майнеров. Часть 4

Зависит ли логика контракта от порядка транзакций?

Описание: Майнеры контролируют порядок транзакций и могут использовать это для атак типа «фронт-раннинг», «бэк-раннинг» или «сэндвич».

Устранение: Реализуйте защиту, позволяя пользователям указывать приемлемые результаты, которые отменяют транзакции в случае нарушения.

Майнеры определяют порядок включения транзакций в блок. Хотя майнеры обычно отдают приоритет транзакциям с более высокими ценами на газ, они не обязаны этого делать. Это позволяет злонамеренным майнерам (или сложным ботам) стратегически упорядочивать транзакции в своих интересах. Такое использование может привести к фронтран, бекран или сэндвич атакам. Эти атаки используют манипуляции с порядком транзакций для извлечения выгоды.

Представьте себе децентрализованную биржу (DEX). Майнер видит в мемпуле крупный ордер на покупку определенного токена. Он может вставить свой собственный ордер на покупку перед крупным ордером (фронт-раннинг), что приведет к росту цены. Затем он может вставить свой ордер на продажу после крупного ордера (бэк-раннинг или сэндвич-атака), извлекая прибыль из роста цены, вызванного первоначальной сделкой.

Вот упрощенная уязвимая DEX:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;


import "@openzeppelin/contracts/token/ERC20/ERC20.sol";


// Simple ERC20 token for testing
contract TestToken is ERC20 {
    constructor(string memory name, string memory symbol, uint256 initialSupply) ERC20(name, symbol) {
        _mint(msg.sender, initialSupply);
    }
}


// Simplified DEX that's vulnerable to front-running
contract VulnerableDEX {
    TestToken public tokenA;
    TestToken public tokenB;
    uint public reserveA;
    uint public reserveB;


    constructor(address _tokenA, address _tokenB) {
        tokenA = TestToken(_tokenA);
        tokenB = TestToken(_tokenB);
    }


    // Initialize liquidity
    function addLiquidity(uint amountA, uint amountB) external {
        tokenA.transferFrom(msg.sender, address(this), amountA);
        tokenB.transferFrom(msg.sender, address(this), amountB);
        reserveA += amountA;
        reserveB += amountB;
    }


    // Calculate output amount for a given input
    function _calculateSwapOutput(address tokenIn, uint amountIn) internal view returns (uint amountOut) {
        require(tokenIn == address(tokenA) || tokenIn == address(tokenB), "Invalid token");


        bool isTokenA = tokenIn == address(tokenA);


        if (isTokenA) {
            amountOut = (reserveB * amountIn) / (reserveA + amountIn);
            require(amountOut < reserveB, "Insufficient liquidity");
        } else {
            amountOut = (reserveA * amountIn) / (reserveB + amountIn);
            require(amountOut < reserveA, "Insufficient liquidity");
        }


        return amountOut;
    }


    // Execute the swap with pre-calculated output
    function _executeSwap(address tokenIn, uint amountIn, uint amountOut, address sender) internal {
        bool isTokenA = tokenIn == address(tokenA);


        if (isTokenA) {
            tokenA.transferFrom(sender, address(this), amountIn);


            // Update reserves
            reserveA += amountIn;
            reserveB -= amountOut;


            // Transfer output tokens to the user
            tokenB.transfer(sender, amountOut);
        } else {
            tokenB.transferFrom(sender, address(this), amountIn);


            reserveB += amountIn;
            reserveA -= amountOut;


            tokenA.transfer(sender, amountOut);
        }
    }


    // Vulnerable swap function (no minimum output)
    function swap(address tokenIn, uint amountIn) external returns (uint amountOut) {
        // Calculate the expected output
        amountOut = _calculateSwapOutput(tokenIn, amountIn);


        // Execute the swap
        _executeSwap(tokenIn, amountIn, amountOut, msg.sender);


        return amountOut;
    }
}

В этом контракте VulnerableDEX функция обмена не имеет защиты от проскальзывания, что делает ее уязвимой для атак типа «сэндвич». Эти атаки являются формой эксплуатации максимально извлекаемой стоимости (MEV), при которой прибыль извлекается путем манипулирования порядком транзакций.

Когда жертва отправляет транзакцию обмена в мемпул, опытные поисковики MEV выявляют возможность и выполняют трехэтапную атаку:

1. Фронтранинг: сначала злоумышленник размещает транзакцию на покупку целевого актива, намеренно завышая цену.
‍
2. Транзакция жертвы: своп жертвы выполняется по этой искусственно завышенной цене, и она получает меньше токенов, чем ожидалось, из-за отсутствия гарантий минимального выхода.
‍
3. Бэкранинг: злоумышленник продает ранее приобретенные токены по более высокой цене, созданной транзакцией жертвы, получая разницу в цене в качестве прибыли.

Хотя любой участник, отслеживающий mempool, может осуществлять атаки типа «сэндвич», производители блоков обладают привилегированными возможностями по упорядочиванию транзакций, что позволяет им осуществлять такие атаки с большей степенью уверенности.

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

Вот пример защиты от проскальзывания, которая смягчает последствия атаки типа «сэндвич», описанной в тесте выше.

// Secure swap function with minimum output requirement
    function swapWithMinimumOutput(
        address tokenIn,
        uint amountIn,
        uint minAmountOut
    ) external returns (uint amountOut) {
        // Calculate the expected output
        amountOut = _calculateSwapOutput(tokenIn, amountIn);


        // Check slippage before executing the swap
        require(amountOut >= minAmountOut, "Slippage too high");


        // Execute the swap
        _executeSwap(tokenIn, amountIn, amountOut, msg.sender);


        return amountOut;
    }

#miner #mev

Про современный вайбкоддинг

Несколько месяцев назад, вроде как в начале лета, я писал пост про вайбкоддинг и то, что современные ИИ достаточно далеки от того, чтобы самостоятельно писать код, готовый для продакшена.

Ситуация начинает меняться очень и очень быстро.

Я много экспериментирую с различными нейронками и редакторами, шаг за шагом продвигаясь и в собственном обучении ml/dl и в разработке пары проектов. И могу с уверенностью сказать, что ИИ сделали просто невероятный шаг в разработке кода за последнее время. С небольшой поправкой: если вы понимаете, что делаете.

Сейчас я использую Cursor IDE в 90% своей работы с кодом, с использованием Claude 4 (4.1, 4.5). Также экспериментирую с Qwen-Coder, CLM-4.5 (4.6) и GPT5. Работу с CLI пока не довелось хорошенько погонять...

И знаете что? В рамках IDE они действительно могут понимать контекст задачи и писать хороший код. При этом вы сами должны понимать, что ИИ пытается реализовать и помещать его в определенные рамки, как например, не добавлять не нужную отладку, не создавать тестовые файлы и т.д. Другими словами, ИИ будет делать то, что вы ему говорить, а не что ожидаете от него в своих мыслях.

Все идет к тому, что скоро у разработчиков пойдет смещение со стороны написания кода, на его аудит и чтение. Зачем тратить время на написание функции, когда я могу дать четкие указания ИИ на написание функции с нужными параметрами и проверками, а затем проаудировать код?

На мой взгляд, скоро будет важнее иметь теоретические знания, чем практические (где-то в соотношении 80% - 20%). При этом ваша теория должна быть настолько хороша, чтобы вы могли объяснить ее малолетнему ребенку.

Складывается таке ощущение, что скоро будут появляться больше информации с примерами функций или программ, с детальными комментариями к промту и требованиям, чтобы этот код написать.

Например, вместо примера контракта обычного токена, будет идти небольшое описание этого контракта и промт для ИИ, в котором будет расписана структура этого контракта: какие функции должны быть включены, что они должны делать, какие проверки в этих функциях должны быть, как они должны взаимодействовать друг с другом и т.д. При этом важно учитывать то, что ИИ уже будут знать эталонные примеры контрактов из библиотек Open Zeppelin, Uniswap или Chainlink.

Если вы думаете, что станет больше работы для Интернов и Джунов, то спешу вас огорчить.

Хороший промт может написать только уверенный мидл, как и проверить его написание после ИИ.

Давно я писал, что с каждым годом требования к соискателям даже на начальные позиции будут все более широкие: там где сначала требовалось знать только Solidity, потом потребовались знания написания тестов, потом базовой безопасности смарт контрактов, а теперь еще и навыки работы с ИИ и промтинга.

ИИ облегчит разработку в рамках "времени", но не профессиональных знаний.

#ai #vibecoding #solidity

Контекст смарт контракта для AI

Сегодня просто решил поделиться с вами своими наблюдениями, которые я получил создавая небольшой проект на стыке AI/Web3.

В рамках задачи мне нужно было каким-то образом сжать смарт контракт для отправки его в модель LLM для анализа. Само сжатие потребовалось, чтобы уместить один или несколько смарт контрактов в рамки контекстного окна модели. Для тех, кто не в курсе, далее чуть поясню суть проблемы.

Несмотря на то, что современные модели могут иметь контекстные окна (тот объем информации, который они могут обработать за раз) от 200 000 до 1 000 000 токенов, активное внимание хорошо работает только примерено до 100 000 токенов. Другими словами, до этого объема они могут эффективно следовать инструкциям и "не забывать" условия и суть задачи.

Запросы пользователя в чатах не такие уж и большие, зачастую всего 50-250 токенов, поэтому общение в чате может быть достаточно долгим, если не просить модель отвечать развернуто.

Однако проблемы начинают возникать тогда, когда требуется в одном запросе отправить:

пользовательское сообщение + системный промт + контракт + документацию

Детально написанный системный промт может занимать 5к-15к токенов, длинный контракт около 8к-10к, документация и того больше. В итоге один запрос для хорошего анализа смарт контракта может занимать около 30к-40к токенов. И вроде бы ок, если не думать, что для более глубокого анализа связей между функциями нужно добавить еще 2-3 контракта, которые наследуются в первом. И тут уже контекст растет значительно!

Поэтому мне и нужно было как-то сжимать контракты и документацию, чтобы уменьшать количество используемых токенов, хотя бы на 30%-40%, а лучше и больше.

К сожалению, удаление комментариев из файла контракта, уменьшение пробелов и переносов строк, могут бать максимум 5%-8% сокращения. И этого мало.

Общение с ИИ также не сильно помогает: в большинстве своем они дают самые очевидные советы.

Однажды мне пришла мысль, что можно заменить самые часто повторяющиеся слова в контрактах (function, public, view, balanceOf) на какие-либо символы - типа тех же смайлов, так как по уверениям ChatGPT, смайлы занимают всего один токен.

P.S. Тут к слову сказать, что зачастую 1 токен равен около 3,5-4 символам текста, но для разных ИИ это могут быть разные значения.

И вроде как логично, 1 смайл - 1 токен. Но все оказалось сложнее.

Сначала нужно было узнать те самые популярные слова в контактах. Благо в сети можно найти отличные подборки контрактов, которые использовали в различных датасетах. Я получил около 130 000 реальных контрактов.

Затем с помощью простого скрипта на Python, я собрал самые повторяющиеся слова, которых вышло около 150 000 всего. Слов которые повторялись более 500 раз на эту подборку было около 10 000. Их я и решил использовать.

Далее я написал небольшой скрипт, который используя популярные библиотеки для подсчета токенов (antropic, openai, huggingface и базовый - 1 токен/4 символа), прогнал все 10 000 слов.

Далее, собрал все PUA / emoji / редкие символы (UU+E000–U+F8FF) и также прогнал их через скрипт подсчета токенов.

И тут было мое разочарование. Оказалось, что большинство популярных слов в смарт контрактах и так составляют всего 2-3 токена, как и смайлы!

OnlyOwner, balanceOf и другие популярные переменные занимают столько же места в контексте, что и :)!

В данном эксперименте я не учет способ обучения модели на данных! Когда, грубо говоря, GPT обучается на смарт контрактах и видит миллионы из них, то самые часто употребляющиеся слова "сливаются" в меньшее количество токенов, и не зависит от количества символов в слове! Другими словами, модель сама себя оптимизирует по контексту, и таким образом программный код занимает минимально возможное количество токенов. (На самом деле процесс немного сложнее, но суть примерно та же).

И от этой идеи пришлось отказаться...

Но есть пара других: кардинально другой подход, который на первых тестах показал сокращение количества токенов на 45%! Экспериментирую с ним дальше!

Вот такая короткая история! Если у вас были схожие задачи и вы смогли их решить, буду рад, если поделитесь в комментариях!

#ai #contracts

Изучайте Vibe codding и AI в web3

Несмотря на то, что я сейчас реже публикую посты в Твиттере, я по-прежнему каждый день слежу за новостями и лидерами мнений в сфере web3. И меня не перестаёт удивлять некоторая двойственность в их поведении: с одной стороны, они открыто иронизируют над «вайб-кодингом» и теми, кто пишет код и тесты с помощью ИИ, а с другой — в комментариях под другими постами с жаром спорят, какой же ИИ-помощник лучше: ChatGPT или Claude.

Это напомнило мне время, когда я работал фуллстек-разработчиком и в 90% случаев использовал PHP. Тогда многие твердили, что PHP — это «отстой» и пора переходить на Python. Как-то раз я наткнулся на замечательное сравнение:

«PHP — как самокат. Отличная штука, но из-за того, что на нём может поехать кто угодно, его репутация ниже плинтуса».

Похожая ситуация и здесь. Многие аудиторы и разработчики уже давно используют ИИ-редакторы кода, но почему-то стесняются в этом признаваться — возможно, боятся, что это уронит их репутацию. Странно, не правда ли?

На мой взгляд, вайб-кодинг — это просто инструмент. Если вы понимаете, как должна работать программа, какие алгоритмы выбрать и как всё устроено под капотом, то ИИ кардинально сократит время разработки. Это освободит вам время для проверки гипотез и исследования жизнеспособности идеи. А если вы и без ИИ писали не самый качественный код, то и с ним результат будет таким же.

Я уверен, что в течение года в каждой уважающей себя компании появятся свои пайплайны для работы с ИИ: агенты, инструменты для разработки, векторные базы данных, ассистенты и многое другое. И важно уже сейчас начинать разбираться в этом, чтобы уметь встроиться в этот процесс.

То же самое ждёт и сферу разработки смарт-контрактов. Web3 — лакомый кусок для финансового мира. Крупные компании и создатели языковых моделей так или иначе будут обучать их написанию контрактов, ботов и сетей. За последние полгода они уже серьёзно продвинулись и будут становиться только лучше.

Да, для этого нужна тщательная выборка безопасных контрактов для обучения. Но с другой стороны, эти же модели учатся и на аудиторских отчётах. Так что в какой-то момент ИИ сможет не только написать код, но и проанализировать его на типичные ошибки, исправить их и предоставить готовое решение.

Всё это упростит жизнь разработчикам, но усложнит — аудиторам. Уже не получится просто написать в отчёте: «send() небезопасен», потребуется более глубокий анализ.

Что я хочу сказать? Уже сейчас стоит активно осваивать вайб-кодинг и не стесняться этого. Создавайте мини-проекты, выкладывайте код в опенсорс, делитесь опытом.

Учитесь и не обращайте внимания на тех, кто пытается вас пристыдить. Будущее — за теми, кто умеет работать с инструментами, а не игнорирует их.

#vibe #ai

Атаки с манипулированием ценами. Часть 1

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

Сегодня мы углубимся в тему атак с манипулированием ценами.

Эти атаки являются распространенной угрозой в децентрализованных финансах (DeFi), использующей уязвимости в протоколах для искусственного искажения цен на активы с целью получения незаконной прибыли. Только в 2024 году эти атаки привели к убыткам на сумму более 52 миллионов долларов в 37 инцидентах, что делает их вторым по ущербу вектором атак. Злоумышленники часто используют флэш-кредиты или уязвимости оракулов для создания ценовых диспропорций, что влияет на такие критически важные компоненты, как кредитные платформы, децентрализованные биржи (DEX) и стейблкоины.

Как цена рассчитывается по соотношению балансов токенов?

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

Давайте рассмотрим, как злоумышленник использует простую DEX, где цена определяется непосредственно на основе балансов токенов.

// Pool.sol (Simplified for illustration)
// Represents a simple liquidity pool vulnerable to balance manipulation
contract Pool is FlashLoanProvider { // Assume FlashLoanProvider is implemented elsewhere
    IERC20 public immutable tokenA;
    IERC20 public immutable tokenB;


    constructor(IERC20 _tokenA, IERC20 _tokenB) {
        tokenA = _tokenA;
        tokenB = _tokenB;
    }


    // Simplified swap function
    function swap(IERC20 tokenIn, uint256 amountIn) external returns (uint256 amountOut) {
        require(tokenIn == tokenA || tokenIn == tokenB, "invalid token");
        IERC20 tokenOut = tokenIn == tokenA ? tokenB : tokenA;


        // Transfer tokens in
        require(tokenIn.transferFrom(msg.sender, address(this), amountIn), "transfer in failed");


        // Calculate amount out based on price
        uint256 price = getPrice(tokenIn, tokenOut);
        amountOut = amountIn * price / 1e18;


        // Transfer tokens out
        require(tokenOut.transfer(msg.sender, amountOut), "transfer out failed");


        return amountOut;
    }


    // Vulnerable price calculation based on current pool balances
    function getPrice(IERC20 tokenIn, IERC20 tokenOut) public view returns (uint256) {
        uint256 balIn = tokenIn.balanceOf(address(this));
        uint256 balOut = tokenOut.balanceOf(address(this));


        if (balIn == 0 || balOut == 0) {
            return 1e18; // 1:1 initial price
        }


        // Price is the ratio of output token to input token
        return balOut * 1e18 / balIn;
    }


    // ... (flashLoanExternal and FlashLoanProvider logic assumed) ...
}


// Exploit.sol (Simplified for illustration)
// Contract to execute the flash loan and exploit
contract Exploit is IFlashLoanReceiver {
    Pool public pool;
    IERC20 public tokenA;
    IERC20 public tokenB;
    address public attacker;


    constructor(
        Pool _pool,
        IERC20 _tokenA,
        IERC20 _tokenB,
        address _attacker
    ) {
        pool = _pool;
        tokenA = _tokenA;
        tokenB = _tokenB;
        attacker = _attacker;
    }


    function attack(uint256 loanAmount) external {
        // Get the flashloan of tokenA
        pool.flashLoanExternal(address(this), tokenA, loanAmount);
    }


    function receiveFlashLoan(IERC20 token, uint256 loanAmount) external override {
        require(token == tokenA, "Expected tokenA flash loan");

        // Step 1: Now the pool has less tokenA, so the price of tokenA (in terms of tokenB) is higher


        // Step 2: Swap tokenA for tokenB at this manipulated rate
        uint256 swapAmount = 100 * 1e18;
        tokenA.transferFrom(attacker, address(this), swapAmount);
        tokenA.approve(address(pool), swapAmount);
        uint256 receivedB = pool.swap(tokenA, swapAmount);


        // Step 3: Repay the flash loan
        tokenA.transfer(address(pool), loanAmount);


        // Step 4: Send profits to attacker
        uint256 remainingBalanceA = tokenA.balanceOf(address(this));
        uint256 remainingBalanceB = tokenB.balanceOf(address(this));


        if (remainingBalanceA > 0) {
            tokenA.transfer(attacker, remainingBalanceA);
        }


        if (remainingBalanceB > 0) {
            tokenB.transfer(attacker, remainingBalanceB);
        }
    }
}

В этом сценарии функция getPrice контракта пула рассчитывает обменный курс на основе текущих остатков tokenA и tokenB, хранящихся в пуле. Эта зависимость от внутреннего, легко изменяемого состояния является основной уязвимостью.

Как работает атака?

1. Настройка: злоумышленник финансирует контракт Exploit небольшой суммой токена A (swapAmount), которую он будет использовать для свопа.

2. Flashloan: злоумышленник вызывает атаку на контракт Exploit, инициируя крупный флэш-кредит токена A из самого контракта Pool. Этот кредит выполняется до того, как функция receiveFlashLoan возвращает результат.

3. Манипулирование ценой (внутри receiveFlashLoan): пока флэш-заем активен, баланс токена A в пуле искусственно занижен. Когда контракт Exploit вызывает pool.swap(tokenA, swapAmount), функция getPrice пула рассчитывает цену на основе этих временно искаженных низких резервов токена A. Это приводит к манипулированию ценой, в результате чего токен A выглядит гораздо более ценным, чем в нормальных условиях.

5. Своп (внутри receiveFlashLoan): контракт Exploit обменивает небольшую сумму собственного предварительно профинансированного tokenA на tokenB с помощью функции pool.swap. Из-за манипулируемой цены этот своп приносит непропорционально большую сумму tokenB.

6. Погашение кредита (внутри receiveFlashLoan): контракт Exploit погашает крупный флэш-кредит tokenA контракту Pool. Вызов receiveFlashLoan должен завершиться успешно, что означает погашение кредита.

7. Прибыль (после возврата receiveFlashLoan): Контракт Exploit теперь содержит исходное количество tokenA (или немного меньше из-за комиссий, хотя в этом упрощенном примере комиссии опущены) плюс избыточное количество tokenB, полученное в результате манипулирования свопом. Оставшиеся токены отправляются обратно на адрес злоумышленника, что приносит прибыль в tokenB.

Исправление: использование надежных источников цен (оракулов)

Надежным решением является отказ от использования соотношений балансов в цепочке для расчета цен и интеграция внешних оракулов цен, таких как Chainlink. Оракулы предоставляют надежные, защищенные от подделки данные о ценах вне цепочки, что значительно упрочняет контракты против манипуляций, основанных на внутреннем состоянии.

Получая цены из фида Chainlink, контракт отделяет свою ценовую логику от внутреннего, поддающегося манипуляциям состояния и внешних, нестабильных спотовых рынков, что значительно сокращает поверхность атаки.

#price

Атаки с манипулированием ценами. Часть 2

Спотовые цены, полученные непосредственно из пулов ликвидности DEX, уязвимы для манипуляций с помощью флэш-кредитов, которые могут временно истощить пулы.

В предыдущем разделе мы установили, что полагаться исключительно на внутренние соотношения баланса токенов контракта для ценообразования небезопасно. Однако как насчет получения цен из внешних источников, таких как крупные пулы ликвидности DEX (например, Uniswap, SushiSwap)? Несмотря на риски, спотовые цены DEX по-прежнему привлекают разработчиков своими очевидными преимуществами: децентрализованным характером, экономической эффективностью (отсутствие комиссий оракула), прозрачностью и мгновенным ценообразованием, особенно для новых токенов. В отличие от специализированных сетей оракулов, они используют только данные из цепочки, что, по-видимому, позволяет избежать внешних зависимостей.

Но их математическая простота, напрямую связанная с волатильными резервами пула (x * y = k), делает их мишенью для манипуляций посредством стратегических сделок, аналогично примеру с меньшим пулом, который мы обсуждали. Злоумышленники могут воспользоваться этим, выполняя крупные сделки (часто финансируемые за счет флэш-кредитов), чтобы временно исказить баланс пула, вызывая резкий скачок или падение спотовой цены, сообщаемой пулом, в зависимости от направления сделки. Этот риск особенно выражен для пулов с низкой ликвидностью, где даже сделки умеренного размера могут вызвать значительные ценовые сдвиги.

Для того, чтобы смягчить влияние манипуляций с ценами с помощью внезапных изменений спотовой цены, можно использовать TWAP. Вместо того, чтобы делать мгновенный снимок (спотовая цена), TWAP усредняет цены за определенный период, обычно от нескольких минут до нескольких часов.

Это значительно ослабляет влияние краткосрочных манипуляций. TWAP работает путем записи кумулятивных цен через определенные интервалы и вычисления средней цены между двумя временными метками.

Чтобы значительно исказить TWAP в течение его окна, злоумышленник должен поддерживать искаженную цену в течение всего этого окна. Это значительно более затратное мероприятие, чем кратковременная манипуляция с помощью флэш-кредитов. Особенно в пулах с высокой ликвидностью, сделки, необходимые для поддержания искаженной цены, повлекут за собой существенное проскальзывание или потребуют огромного капитала.

Протоколы, такие как Uniswap, предлагают собственные оракулы TWAP, встроенные непосредственно в их контракты.

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

#price

Насколько хороши аудиторские отчеты?

Вы когда-ниодь задумывались о том, насколько развернутыми и качественными бывают аудиторские отчеты для смарт-контрактов? За последние четыре месяца я собрал и проанализировал базу из более чем двадцати четырех тысяч уязвимостей, извлеченных из отчетов частных аудиторов, компаний и конкурсных платформ. Эта работа стала фундаментом для создания интеллектуального ассистента, призванного помогать в аудите. Ключевым этапом была оценка информационной ценности каждого отдельного отчета.

Для этого была разработана система взвешивания. Основной вклад вносили три компонента: детальное описание проблемы, рекомендации по ее устранению и наличие доказательства концепции (PoC). Наибольший вес был назначен доказательству концепции, так как его наличие существенно повышает практическую ценность отчета. Дополнительные баллы начислялись за включение фрагментов кода на Solidity и за уровень серьезности самой уязвимости.

Для того, чтобы система оценок была более справедливой и сбалансированной, сырые баллы прошли процесс нормализации. Была применена логарифмическая функция, которая сжимает исходный диапазон значений от нуля до пятнадцати в интервал от нуля до единицы. Это предотвратило ситуацию, при которой несколько идеальных отчетов с максимальными баллами доминировали бы над всеми остальными, и позволило выстроить более плавный и информативный градиент качества.

Статистический анализ полученных данных выявил любопытные закономерности. Средний вес по всем отчетам составил 0.32 при медианном значении 0.27. Это означает, что половина всех проанализированных отчетов имеет оценку ниже 0.27. Распределение весов является скошенным, с явным пиком в области низких значений, что указывает на преобладание относительно кратких или неполных описаний уязвимостей.

Качественными можно считать лишь около четверти всех отчетов, чей вес превышает значение 0.51. Наличие доказательства концепции и сопровождающего его кода является ключевым фактором, который отделяет эту группу от общей массы. Именно эти отчеты формируют так называемый золотой фонд данных, наиболее пригодный для эффективного обучения моделей искусственного интеллекта.

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

Такой анализ подчеркивает важность не только обнаружения уязвимости, но и качества ее документации для всего сообщества. Полнота отчета напрямую влияет на скорость и точность его обработки как человеком, так и алгоритмом, что в конечном счете способствует повышению общего уровня безопасности в экосистеме блокчейна.

#notsosmart

Replay атака. Часть 1

Атака повторного воспроизведения происходит, когда действительная передача данных, такая как подписанное сообщение или транзакция, злонамеренно повторяется. В смарт контрактах злоумышленник перехватывает законное, подписанное действие пользователя. Затем он «воспроизводит» его позже в другой сети, чтобы вызвать непреднамеренное изменение состояния, такое как списание средств или выполнение разрешенной функции без авторизации.

Для защиты от таких атак разработчики используют несколько важных инструментов:

1. Nonce («одноразовое число»): в блокчейне nonce — это уникальный последовательный счетчик, привязанный к адресу пользователя. Требуя, чтобы каждое подписанное действие включало текущее nonce пользователя, контракт может гарантировать, что каждое действие будет выполнено только один раз. После обработки nonce увеличивается, поэтому подпись не может быть использована повторно.

2. Параметры, специфичные для цепочки: с появлением нескольких блокчейнов, совместимых с Ethereum Virtual Machine (EVM) (например, Ethereum, Polygon, Arbitrum и т. д.), приватный ключ и адрес пользователя часто одинаковы во всех сетях. Подпись, созданная для контракта на Ethereum, может быть действительна для идентичного контракта на Polygon, если она не содержит данных, специфичных для этой сети. Включение block.chainid в подписанные данные связывает подпись с одной конкретной сетью, предотвращая межсетевые атаки повторного воспроизведения.

3. Разделитель домена: это криптографический механизм, стандартизированный в EIP-712, который связывает подпись с конкретным контекстом приложения. Это уникальный хеш, содержащий такую информацию, как название контракта, версия, адрес и chainid. Это гарантирует, что подпись, предназначенная для одного децентрализованного приложения (DApp), не может быть повторно использована в другом, обеспечивая надежную защиту как от межсетевых, так и от cross-DApp атак повторного воспроизведения.

Теперь давайте рассмотрим, как применять эти механизмы к конкретным уязвимостям.

Существуют ли меры защиты от атак повторного воспроизведения для неудачных транзакций?

Эта проверка сосредоточена на распространенном недостатке реализации: увеличение nonce пользователя только после успешного завершения транзакции. Если транзакция завершается неудачно из-за временных обстоятельств (например, в контракте недостаточно средств), nonce остается неизменным. Подписанное сообщение по-прежнему остается действительным и может быть повторно использовано любым лицом после устранения обстоятельств.

Рассмотрим контракт RewardSystem, который позволяет пользователям получать заработанные вознаграждения.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;


import "openzeppelin-contracts/contracts/access/Ownable.sol";
contract RewardSystem is Ownable {
    mapping(address => uint256) public rewards;
    mapping(address => uint256) public nonces;


    constructor() Ownable(msg.sender) {}


    // For PoC simplicity, we don't use real signatures
    function claimReward(address user, uint256 amount, uint256 nonce, bytes memory signature) external {
        require(rewards[user] >= amount, "Insufficient reward balance");
        require(nonces[user] == nonce, "Invalid nonce");


        // Vulnerability: Signature can be replayed once contract has funds
        bytes32 messageHash = keccak256(abi.encode(
            user,
            amount,
            nonce
        ));


        // For PoC, use a simple signature check
        bytes32 signedHash = abi.decode(signature, (bytes32));
        require(signedHash == messageHash, "Invalid signature");


        // Attempt to transfer reward
        rewards[user] -= amount;
        (bool success,) = msg.sender.call{value: amount}("");


        // Vulnerability: Nonce is only incremented if transfer succeeds
        if (success) {
            nonces[user]++;
        } else {
            revert("Transfer failed");
        }
    }


    // Helper function to add rewards - only owner can call
    function addReward(address user, uint256 amount) external onlyOwner {
        rewards[user] += amount;
    }


    // Helper function to receive ETH
    receive() external payable {}
}

Функция claimReward увеличивает значение nonce пользователя только в случае успешного перевода ETH. Если в контракте нет ETH, msg.sender.call завершится с ошибкой, транзакция будет отменена, а значение nonces[user] не будет увеличено. Подпись пользователя, которая была действительна для этого значения nonce, остается действительной.

Злоумышленник может отслеживать эти неудачные заявки. Как только контракт RewardSystem будет профинансирован, злоумышленник может повторить исходную транзакцию пользователя, направив вознаграждение на свой собственный адрес.

Как исправить: используйте nonce в каждом пути выполнения!

Убедитесь, что nonce используется (помечается как использованный) в каждом пути выполнения, независимо от того, завершилось ли оно успешно или неудачно. Лучшая практика заключается в том, чтобы использовать nonce сразу после его проверки и убедиться, что транзакция не будет отменена после этого момента. Таким образом, даже если транзакция завершится неудачно, nonce все равно будет увеличен, что предотвратит атаки повторного воспроизведения.

// Corrected claimReward function (inside RewardSystem)
function claimReward(address user, uint256 amount, uint256 nonce, bytes memory signature) external {
    require(rewards[user] >= amount, "Insufficient reward balance");
    require(nonces[user] == nonce, "Invalid nonce");


    // For PoC, use a simple signature check
    bytes32 messageHash = keccak256(abi.encode(user, amount, nonce));
    bytes32 signedHash = abi.decode(signature, (bytes32));
    require(signedHash == messageHash, "Invalid signature");


    // REMEDIATION 1: Consume nonce right after validating it
    nonces[user]++;


    rewards[user] -= amount;
    (bool success,) = msg.sender.call{value: amount}("");


    if (!success) {
        // Revert the reward deduction if transfer failed
        rewards[user] += amount;
    }
    // REMEDIATION 2: No revert to ensure nonce is consumed
}

С этим исправлением, даже если передача не удалась, nonce становится недействительным. Злоумышленник не может повторно использовать подпись, поскольку контракт теперь будет ожидать nonce + 1.

#replay

Replay атака. Часть 2

Существует ли защита от повторного использования подписей в разных сетях?

Этот пункт проверки касается критической уязвимости нескольких сетей. Поскольку приватный ключ пользователя контролирует его адрес во всех сетях EVM, подпись, созданная для контракта на Ethereum, может быть повторно использована при идентичном развертывании этого контракта на Polygon, Arbitrum или любой другой сети EVM. Если подпись не содержит идентификатор блокчейна, она становится универсальным ключом, который злоумышленник может использовать в разных сетях.

Рассмотрим контракт VulnerableVault, предназначенный для того, чтобы его владелец мог изменить получателя с помощью подписанного сообщения.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;


contract VulnerableVault {
    address public owner;
    address public recipient;
    mapping(bytes32 => bool) public isConsumed;


    constructor(address _owner, address _recipient) {
        owner = _owner;
        recipient = _recipient;
    }


    function changeRecipient(address _newRecipient, uint256 _expiry, bytes memory _signature) external {
        require(block.timestamp <= _expiry, "Signature expired");


        // VULNERABILITY: Missing chain ID in the signature data
        bytes32 messageHash = keccak256(abi.encode(
            msg.sender, // In the PoC, this is the test contract's address
            _newRecipient,
            _expiry
        ));


        // For PoC, use a simple signature check
        bytes32 signedHash = abi.decode(_signature, (bytes32));
        require(signedHash == messageHash, "Invalid signature");
        require(!isConsumed[messageHash], "Signature already used");


        isConsumed[messageHash] = true;
        recipient = _newRecipient;
    }
}

MessageHash включает нового получателя и метку времени истечения срока действия, но в нем отсутствует block.chainid. Это означает, что подпись, сгенерированная для этого действия, является переносимой, т. е. злоумышленник может взять действительную подпись из одной сети и использовать ее в другой.

Исправление: встраивание данных, специфичных для цепочки, в подписи.

Прямым исправлением является включение block.chainid в данные, которые хэшируются и подписываются. Это навсегда привязывает подпись к одной сети. Для более надежного и стандартизированного решения используйте EIP-712, который встраивает эту защиту непосредственно в свою структуру через разделитель домена.

Вот простое исправление, примененное к новому контракту SecureVault.

// Corrected changeRecipient function (inside a new SecureVault contract)
contract SecureVault {
    // ... same state variables and constructor as VulnerableVault ...
    address public owner;
    address public recipient;
    mapping(bytes32 => bool) public isConsumed;


    constructor(address _owner, address _recipient) {
        owner = _owner;
        recipient = _recipient;
    }


    function changeRecipient(address _newRecipient, uint256 _expiry, bytes memory _signature) external {
        require(block.timestamp <= _expiry, "Signature expired");


        // REMEDIATION: Include the chain ID to make the signature chain-specific.
        bytes32 messageHash = keccak256(abi.encode(
            msg.sender,
            _newRecipient,
            _expiry,
            block.chainid // Added chain ID
        ));


        // For PoC, use a simple signature check
        bytes32 signedHash = abi.decode(_signature, (bytes32));
        require(signedHash == messageHash, "Invalid signature");
        require(!isConsumed[messageHash], "Signature already used");


        isConsumed[messageHash] = true;
        recipient = _newRecipient;
    }
}

Атаки с повторным воспроизведением используют действительные намерения пользователей в недействительных контекстах. Понимая, как злоумышленники могут дублировать действия во времени или между сетями, мы можем встроить в наши контракты более точную и безопасную логику проверки.

Разработка безопасных контрактов требует верной точки зрения:

- Всегда спрашивайте: полностью ли я аннулировал эту подпись после использования? Nonce должен быть использован независимо от того, удалась ли транзакция или нет.

- Проверяйте контекст подписи: где эта подпись действительна? Если ваш протокол работает или может работать в нескольких сетях, каждая внесетевая подпись должна быть привязана к конкретной сети через block.chainid или разделитель домена EIP-712.

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

Строго применяя эти принципы и используя такие инструменты, как чек-лист Solodit, вы можете создавать системы, устойчивые к этим тонким, но опасным уязвимостям.

#replay

Мое обучение за два месяца

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

Сначала пришлось вернуться к линейной алгебре — векторам, матрицам, операциям над ними, системам линейных уравнений. Без этого невозможно понять даже простейший перцептрон. Потом дошли до собственных значений и векторов, а также до матричных разложений вроде SVD и PCA — инструментов, которые лежат в основе многих методов понижения размерности и сжатия данных.

Параллельно я проходил теорию вероятностей: от базовых понятий вроде случайных событий и условной вероятности до более сложных тем — совместных распределений, теоремы Байеса и даже вводных понятий байесовских сетей. Особенно важными оказались такие концепции, как энтропия, KL-дивергенция и кросс-энтропия — они напрямую связаны с тем, как нейросети учатся и минимизируют ошибку. А закон больших чисел, казалось бы, абстрактный, на деле объясняет, почему стохастический градиентный спуск вообще работает.

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

Постепенно я добрался и до самих нейронных сетей. Начал с искусственного нейрона и перцептрона, затем перешёл к многослойным сетям, функциям активации, прямому и обратному распространению ошибки. Изучил, как работают разные оптимизаторы — от классического SGD до более продвинутых, вроде Adam и RMSprop. Потом пришло время свёрточных нейросетей: разобрался с операциями свёртки и пулинга, изучил ключевые архитектуры — от LeNet и AlexNet до VGG, ResNet и DenseNet. Это открыло понимание того, как решаются задачи компьютерного зрения: классификация, детекция, сегментация.

Недавно начал знакомиться с RAG — подходом, сочетающим поиск по внешним источникам и генерацию текста с помощью языковых моделей, — а также с устройством векторных баз данных, которые лежат в основе таких систем.

И при всём этом я отчётливо понимаю: пройденный путь — лишь начало. То, что я планировал освоить за пару месяцев, скорее всего, займёт не меньше года. Но это не разочарование — наоборот, процесс увлекает всё больше. Каждая новая тема раскрывает связи между, казалось бы, разными областями знаний, и это делает обучение по-настоящему увлекательным.

Хочу подчеркнуть: я не забросил свою основную специализацию. Solidity и разработка смарт-контрактов остаются моей профессиональной основой. Просто сейчас я временно поставил эту работу на паузу, чтобы заложить прочный фундамент в области машинного обучения. В будущем, возможно, эти два направления даже пересекутся — ведь децентрализованные системы и ИИ уже начинают влиять друг на друга. А пока — продолжаю учиться, шаг за шагом.

P.S. Все это не составляет и трети от той программы, что я выкладывал ранее для обучения в этой сфере...

#ai

Развитие языка Solidity в скором будущем

Разработка Solidity входит в новую фазу. Долгое время команда сознательно ограничивала добавление новых функций в Classic Solidity, стремясь не усложнять его реализацию и не создавать архитектурных решений, которые могли бы помешать развитию Core Solidity — нового концепта языка. Язык находился в состоянии мягкой заморозки, поскольку основное внимание уделялось ускоренному созданию Core Solidity, где многие функции могли бы быть реализованы эффективнее — либо через стандартную библиотеку, либо как "синтаксический сахар" (буквальная цитата из статьи).

Однако по мере того как Core Solidity оформился в отдельный подпроект со своей собственной дорожной картой, подход к Classic Solidity был пересмотрен. Теперь планируется внедрение ограниченного набора новых языковых возможностей, которые не противоречат долгосрочной архитектуре Core Solidity. В ближайшее время будет опубликован список таких функций с оценкой их сложности, полезности и совместимости с будущим языком. Хотя не все из них успеют попасть в Classic Solidity до перехода на Core, многие из них считаются необходимыми для экосистемы в целом.

Ближайший релиз — версия 0.9 — не принесёт крупных новых возможностей. Его основная цель — упрощение и очистка кодовой базы. В частности, будет завершён переход на IR-конвейер, оптимизатор станет включённым по умолчанию, а поддержка устаревших функций, таких как .send(), .transfer() и виртуальные модификаторы, будет удалена. Также SMTChecker потеряет поддержку BMC и будет переименован в SolCMC. Эти шаги направлены на снижение технического долга и подготовку основы для будущих изменений.

В последующих версиях, начиная с 0.10, изменения будут ориентированы на сближение Classic Solidity с Core Solidity. Это включает постепенное внедрение нового синтаксиса: постфиксную запись типов, переработанный тернарный оператор, упрощённую нотацию функциональных типов, а также замену «магических» свойств обычными функциями. Параллельно будет заложена заглушка стандартной библиотеки, реализующая часть встроенных возможностей на уровне языка, с поддержкой пользовательских замен.

Особое внимание уделяется взаимодействию между Classic и Core Solidity. Планируется создать единый интерфейс компиляции, позволяющий использовать оба языка в одном проекте. На первом этапе контракты останутся независимыми, но их артефакты будут объединяться в общий выход компилятора. На втором этапе станет возможным импортировать и вызывать свободные функции, события, ошибки и типы между языками, что обеспечит плавный переход и гибкость при разработке.

Core Solidity представляет собой фундаментальное обновление системы типов Solidity с заимствованиями из функциональных и системных языков, таких как Haskell, Rust и Zig. Большинство высокоуровневых конструкций Classic Solidity станут частью стандартной библиотеки, а сам язык будет десахаризироваться в минималистичный внутренний язык SAIL. Он поддерживает параметрический полиморфизм, траиты, вывод типов, алгебраические типы и сопоставление с образцом — всё это создаёт основу для строгой формальной верификации и надёжной разработки.

Стандартная библиотека Core Solidity изначально будет минимальной, чтобы снизить нагрузку на компилятор и упростить его поддержку. Однако её дальнейшее развитие планируется осуществлять через открытый, управляемый сообществом процесс, аналогичный EIP. Это позволит расширять язык не через изменения компилятора, а через библиотечные решения, что делает экосистему более гибкой и адаптивной.

Наконец, Core Solidity создаётся с прицелом на формальную спецификацию. В отличие от Classic Solidity, который страдает от отсутствия чёткой семантики, новый язык достаточно компактен для полной формализации. Планируется предоставить исполняемую спецификацию, которая послужит эталонной реализацией и инструментом для верификации. Это также поможет избежать фрагментации: все компиляторы смогут следовать единой спецификации, конкурируя по качеству оптимизаций и реализации библиотек, а не по интерпретации языка.

#solidity

OpenAI анонсировала Aardvark

Вчера OpenAI анонсировала Aardvark — автономного агентного исследователя безопасности, основанного на GPT‑5. Эта система призвана изменить подход к обнаружению и устранению уязвимостей в программном обеспечении, смещая баланс в пользу защитников. В условиях, когда ежегодно выявляется десятки тысяч новых уязвимостей, своевременное обнаружение и исправление критических ошибок становится вопросом не только качества кода, но и общей кибербезопасности инфраструктуры.

Aardvark представляет собой прорыв на стыке искусственного интеллекта и информационной безопасности. В отличие от традиционных методов анализа, таких как фаззинг или анализ состава программного обеспечения, Aardvark использует рассуждения на основе крупной языковой модели и взаимодействие с инструментами. Агент имитирует работу человека-исследователя: читает код, анализирует его поведение, пишет и запускает тесты, а также использует внешние утилиты для подтверждения своих выводов.

Процесс работы Aardvark построен на многоэтапном конвейере. На первом этапе система строит модель угроз для репозитория, отражая понимание его архитектуры и целей безопасности. Затем она отслеживает коммиты в реальном времени, сопоставляя изменения с общей моделью и выявляя потенциальные уязвимости. При первом подключении репозитория Aardvark также анализирует всю историю коммитов, чтобы обнаружить уже существующие проблемы.

Каждая найденная уязвимость сопровождается пошаговым объяснением и аннотациями к коду для последующего ручного анализа. Чтобы минимизировать ложные срабатывания, Aardvark пытается воспроизвести уязвимость в изолированной среде. Это позволяет подтвердить её эксплуатируемость и повысить достоверность выводов. Такой подход обеспечивает высокое качество отчётов и снижает нагрузку на команды безопасности.

После подтверждения уязвимости Aardvark автоматически генерирует патч с помощью интеграции с OpenAI Codex. Этот патч проходит дополнительную проверку самим агентом и прикрепляется к отчёту для быстрого применения разработчиками. Весь процесс встроен в существующие рабочие процессы — в частности, через GitHub — и не замедляет цикл разработки, предоставляя при этом конкретные и выполнимые рекомендации.

Помимо классических уязвимостей, Aardvark способен выявлять логические ошибки, неполные исправления и проблемы с конфиденциальностью. За несколько месяцев внутреннего использования в OpenAI и у внешних партнёров система уже обнаружила значимые уязвимости, включая сложные случаи, возникающие только при определённых условиях. В тестах на эталонных репозиториях Aardvark показал 92% полноты обнаружения как реальных, так и искусственно внесённых уязвимостей.

Особое внимание уделяется открытому программному обеспечению. Aardvark уже помог выявить и ответственно раскрыть десятки уязвимостей в open-source проектах, десять из которых получили идентификаторы CVE. OpenAI планирует предоставлять бесплатное сканирование для некоммерческих open-source репозиториев, внося вклад в безопасность всей экосистемы. При этом компания обновила политику раскрытия уязвимостей, сделав её более гибкой и ориентированной на сотрудничество с разработчиками.

Программное обеспечение стало основой современной инфраструктуры, а каждая уязвимость — потенциальной угрозой для бизнеса и общества. Согласно данным OpenAI, около 1,2% коммитов вносят ошибки, которые могут иметь серьёзные последствия. Aardvark предлагает новый, ориентированный на защиту подход: непрерывный, масштабируемый и интегрированный в процесс разработки. Сейчас система доступна в частной бете, и OpenAI приглашает организации и open-source проекты к участию для дальнейшего улучшения её возможностей.

#ai

Rug Pull

Буквально «rug pull» означает действие, при котором кто-то внезапно выдергивает коврик из-под ног другого человека, в результате чего тот неожиданно падает.

В сфере децентрализованных финансов (DeFi) rug pull означает мошенничество, при котором разработчики продвигают новый токен или платформу, а затем внезапно выводят ликвидность (LP) или продают свои активы в больших количествах, что приводит к резкому падению стоимости токена.

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

Административные роли необходимы для поддержания и обновления протоколов, но предоставление неограниченного доступа к активам создает значительную уязвимость. Если злоумышленник получит контроль над ключом администратора, он сможет вывести средства, фактически осуществив «rug pull», истощив резервы протокола. Даже без злого умысла, скомпрометированный ключ из-за нарушения безопасности может привести к серьезным последствиям, подорвав репутацию протокола и доверие пользователей.

Для того, чтобы снизить этот риск, смарт контракты должны быть разработаны таким образом, чтобы минимизировать влияние скомпрометированной или злонамеренной учетной записи администратора. Это включает в себя ограничение административных привилегий, строгий контроль всех действий администратора и внедрение мер безопасности для предотвращения односторонних или немедленных переводов активов. Административные функции должны рассматриваться как точная хирургическая процедура, необходимая, но тщательно ограниченная безопасным, заранее определенным объемом.

Недавним примером этой уязвимости является инцидент с протоколом Zunami в мае 2025 года, в результате которого было потеряно 500 000 долларов в виде залога zunUSD и zunETH. Согласно rekt.news, это не было сложным взломом с использованием флэш-кредитов или манипуляций с ценами. Скорее, это было простое злоупотребление чрезмерно мощной функцией администратора. Лицо с «доступом в режиме бога» вызвало функцию withdrawStuckToken(), опустошив содержимое хранилища.

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

Вот пример того, как злонамеренный или скомпрометированный администратор может опустошить хранилище и осуществить rug pull:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;


contract VulnerableVault {
    address public admin;
    // Maps user addresses to their deposited balances
    mapping(address => uint256) public userBalances;


    constructor() {
        // The deployer of the contract becomes the admin
        admin = msg.sender;
    }


    /// @notice Allows users to deposit Ether into the vault.
    /// A 1% fee is applied to the deposit and sent to a fee pool.
    function deposit() public payable {
        require(msg.value > 0, "Deposit must be greater than zero");


        // Calculate 1% fee. This fee theoretically belongs to the protocol.
        uint256 fee = msg.value / 100; // 1% of deposited amount
        uint256 amountToDeposit = msg.value - fee;


        // User's balance is updated with their net deposit.
        userBalances[msg.sender] += amountToDeposit;
        // The 'fee' part of msg.value remains in the contract's total balance.
        // It is not explicitly tracked in a separate variable, which is a design flaw
        // if only fees should be withdrawable by admin.
    }


    /// @notice Allows users to withdraw their deposited funds.
    /// @param amount The amount to withdraw.
    function withdraw(uint256 amount) public {
        require(userBalances[msg.sender] >= amount, "Insufficient balance");


        // Decrement user's balance and transfer funds.
        userBalances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }


    /// @notice Admin can withdraw *any* amount from the contract's balance.
    /// This is the rug pull vulnerability! This simulates a `withdrawStuckToken()`-like function.
    /// @param amount The amount to withdraw from the contract.
    function adminRugPullWithdraw(uint256 amount) public {
        require(msg.sender == admin, "Admin control required"); // Only admin can call.


        // NO checks to ensure 'amount' is only from accrued fees.
        // The admin can withdraw any amount up to the contract's total Ether balance (address(this).balance),
        // effectively stealing user deposits, as user deposits also contribute to address(this).balance.
        // This function treats all funds in the contract as if they are available for the admin to take.
        require(address(this).balance >= amount, "Insufficient contract balance for withdrawal");
        payable(admin).transfer(amount); // Transfer chosen amount to admin.
    }
}

В этом контракте VulnerableVault функция adminRugPullWithdraw позволяет администратору снимать любую сумму эфира с общего баланса контракта. Это критическая уязвимость. Если ключ администратора скомпрометирован или если лицо, контролирующее ключ, решает действовать злонамеренно (как это было поставлено под сомнение в деле Zunami в отношении «внутренней работы»), оно может использовать эту функцию для снятия всего эфира, депонированного в хранилище, включая средства пользователей.

Оператор require только проверяет, что вызывающий является администратором, полностью игнорируя проверку суммы на соответствие тому, что должно быть законно снято (например, только комиссии протокола, а не основная сумма пользователя).

И для того, чтобы снизить эту уязвимость и предотвратить мошенничество, рассмотрите следующие надежные стратегии:

- Ограничьте доступ администратора к определенным средствам: ограничьте любую функцию вывода администратора только средствами, принадлежащими протоколу (например, собранными комиссиями, средствами казны), и никогда не допускайте вывода депозитов пользователей. Депозиты пользователей должны быть доступны для вывода только самим пользователям.

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

Вот пересмотренная версия контракта, в которой уязвимость устранена за счет введения внутреннего отслеживания комиссий и ограничения вывода средств администратором только на сумму начисленных комиссий:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;


contract SecuredVault {
    address public admin;
    // Maps user addresses to their deposited balances
    mapping(address => uint256) public userBalances;
    // This variable *only* accounts for fees that the admin can withdraw.
    // It's explicitly separated from user balances.
    uint256 public totalAccruedFees;


    constructor() {
        // The deployer of the contract becomes the admin
        admin = msg.sender;
    }


    /// @notice Allows users to deposit Ether into the vault.
    /// A 1% fee is applied to the deposit and sent to a fee pool.
    function deposit() public payable {
        require(msg.value > 0, "Deposit must be greater than zero");


        // Calculate 1% fee
        uint256 fee = msg.value / 100; // 1% of deposited amount
        uint256 amountToDeposit = msg.value - fee;


        userBalances[msg.sender] += amountToDeposit; // User's principal
        totalAccruedFees += fee; // Accrue the fee for the protocol
    }


    /// @notice Allows users to withdraw their deposited funds.
    /// @param amount The amount to withdraw.
    function withdraw(uint256 amount) public {
        require(userBalances[msg.sender] >= amount, "Insufficient balance");


        userBalances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
    }


    /// @notice Admin can only withdraw the total accrued fees.
    /// This prevents the rug pull as admin cannot touch user principal.
    /// @param amount The amount of fees the admin wishes to withdraw.
    function adminWithdrawFees(uint256 amount) public {
        require(msg.sender == admin, "Admin control required");
        // Crucial check: Ensure admin only withdraws what's available in fees,
        // as tracked separately from user principal.
        require(totalAccruedFees >= amount, "Insufficient accrued fees for withdrawal");


        totalAccruedFees -= amount; // Deduct the withdrawn amount from available fees
        payable(admin).transfer(amount); // Transfer only the requested fee amount to admin
    }
}

В этой улучшенной версии SecuredVault функция adminWithdrawFees больше не взаимодействует напрямую с балансами пользователей. Средства пользователей защищены, поскольку они хранятся отдельно от переменной totalAccruedFees. Это снижает риск злоупотребления правами администратора в отношении пользователя, устраняя основную проблему, наблюдавшуюся при атаке Zunami.

#rugpull