Post-Mortem — Les Plus Gros Hacks DeFi du T1 2026

• Pas de protection contre la malléabilité ECDSA

Leçon

Toujours inclure un nonce dans les messages signés :

// Fix
mapping(uint256 => bool) public usedNonces;

function withdraw(
    address to,
    uint256 amount,
    uint256 nonce,  // ← Nonce unique
    bytes memory signature
) external {
    bytes32 messageHash = keccak256(abi.encodePacked(to, amount, nonce));
    address signer = recoverSigner(messageHash, signature);
    require(signer == validator, "Invalid signature");
    require(!usedNonces[nonce], "Nonce used");
    usedNonces[nonce] = true;

    token.transfer(to, amount);
}

2. Manipulation d'Oracle via Prêt Flash (~$32M)

Protocole : YieldFarm Protocol (anonymisé)

Date : 28 janvier 2026

Pertes : $32M

Ce qui s'est passé

Un protocole de lending utilisait un spot price oracle basé sur une pool Uniswap V3.

// Oracle vulnérable
contract PriceOracle {
    IUniswapV3Pool public pool;

    function getPrice() external view returns (uint256) {
        (uint160 sqrtPriceX96,,,,,,) = pool.slot0();
        // ❌ Bug : utilise le prix instantané (manipulable)
        return uint256(sqrtPriceX96) ** 2 >> 192;
    }
}

// Protocole de lending
contract LendingPool {
    function borrow(uint256 collateralAmount) external {
        uint256 collateralValue = oracle.getPrice() * collateralAmount;
        uint256 maxBorrow = collateralValue * 80 / 100;  // 80% LTV
        // ...
    }
}

Exploit :

Cause racine

• Pas de TWAP (time-weighted average price)

• Pool de liquidité insuffisante (manipulation facile)

Leçon

Ne JAMAIS utiliser le prix spot pour des décisions financières critiques.

// Fix : TWAP sur 30 minutes
contract TWAPOracle {
    IUniswapV3Pool public pool;
    uint32 public constant TWAP_PERIOD = 1800;  // 30 min

    function getPrice() external view returns (uint256) {
        uint32[] memory secondsAgos = new uint32[](2);
        secondsAgos[0] = TWAP_PERIOD;
        secondsAgos[1] = 0;

        (int56[] memory tickCumulatives,) = pool.observe(secondsAgos);
        int56 tickCumulativeDelta = tickCumulatives[1] - tickCumulatives[0];
        int24 arithmeticMeanTick = int24(tickCumulativeDelta / int56(uint56(TWAP_PERIOD)));

        return getQuoteAtTick(arithmeticMeanTick);
    }
}

Mieux : utiliser Chainlink ou Pyth pour les prix critiques.

3. Griefing de Restaking Slashing (~$28M)

Protocole : EigenLayer-like Restaking Protocol

Date : 15 février 2026

Pertes : $28M (slashing)

Ce qui s'est passé

Un protocole de restaking permettait de slasher des validators malveillants. L'attaquant a exploité une race condition dans le processus de slashing.

// Contrat de restaking (simplifié)
contract RestakingPool {
    mapping(address => uint256) public stakes;
    mapping(bytes32 => bool) public slashingProofs;

    function slash(
        address validator,
        bytes memory proof
    ) external {
        bytes32 proofHash = keccak256(proof);
        require(!slashingProofs[proofHash], "Already slashed");
        require(verifyMisbehavior(proof), "Invalid proof");

        // ❌ Bug : TOCTOU (time-of-check/time-of-use)
        slashingProofs[proofHash] = true;
        uint256 slashAmount = stakes[validator] / 2;
        stakes[validator] -= slashAmount;
        // ...
    }
}

Exploit : l'attaquant a soumis la même preuve de slashing dans deux transactions dans le même block.

Cause racine

• Pas de reentrancy guard

• Pas de limite sur le slashing total

Leçon

Protéger contre les race conditions et double-exécution :

// Fix
function slash(
    address validator,
    bytes memory proof
) external nonReentrant {  // ← Reentrancy guard
    bytes32 proofHash = keccak256(proof);
    require(!slashingProofs[proofHash], "Already slashed");
    slashingProofs[proofHash] = true;  // ← Marquer AVANT logique

    require(verifyMisbehavior(proof), "Invalid proof");

    uint256 slashAmount = stakes[validator] / 2;
    stakes[validator] -= slashAmount;
    // ...
}

Ou utiliser commit-reveal pour éviter la manipulation MEV.

4. Cascade de Depeg LST (~$40M)

Protocole : Multi-protocol Depeg

Date : 8 mars 2026

Pertes : $40M (liquidations en cascade)

Ce qui s'est passé

Pas vraiment un "hack", mais une cascade de liquidations suite au depeg d'un Liquid Staking Token (LST).

// Protocole de lending (simplifié)
contract LendingPool {
    uint256 public constant LIQUIDATION_THRESHOLD = 120;  // 120%

    function liquidate(address borrower) external {
        uint256 collateralValue = oracle.getPrice(lstToken) * collateral[borrower];
        uint256 debtValue = debt[borrower];

        // Si collateral < 120% de la dette → liquidation
        require(collateralValue * 100 < debtValue * LIQUIDATION_THRESHOLD, "Healthy");

        // ❌ Problème : vente massive → prix chute → plus de liquidations
        uint256 seizeAmount = debt[borrower] * 108 / 100;  // 8% bonus
        lstToken.transferFrom(borrower, msg.sender, seizeAmount);
    }
}

Cause racine

• Collateral non-diversifié (concentration sur 1-2 LSTs)

• Oracles lents (pas de circuit breaker sur depeg rapide)

• Liquidation bonus trop élevé (incentive à liquider massivement)

Leçon

Diversifier le collateral et ajouter des circuit breakers :

// Fix : circuit breaker
contract SafeLendingPool {
    mapping(address => uint256) public lastPrice;
    uint256 public constant MAX_PRICE_CHANGE = 10;  // 10% max par heure

    function liquidate(address borrower) external {
        uint256 currentPrice = oracle.getPrice(lstToken);
        uint256 priceChange = abs(currentPrice - lastPrice[lstToken]) * 100 / lastPrice[lstToken];

        // Circuit breaker : si prix change > 10% → pause liquidations
        require(priceChange <= MAX_PRICE_CHANGE, "Circuit breaker triggered");

        // ...
    }
}

Ou réduire le liquidation bonus pour éviter les incentives pervers.

5. Frontrun d'Intent Cross-Chain (~$15M)

Protocole : Intent-based DEX Aggregator

Date : 22 mars 2026

Pertes : $15M

Ce qui s'est passé

Un nouveau protocole d'intent-based trading cross-chain permettait aux utilisateurs de signer des "intents" (ordres off-chain). Les fillers exécutaient ces intents on-chain.

// Protocole d'intent (simplifié)
struct Intent {
    address user;
    address tokenIn;
    address tokenOut;
    uint256 amountIn;
    uint256 minAmountOut;
    uint256 deadline;
    bytes signature;
}

function fillIntent(Intent memory intent) external {
    require(block.timestamp <= intent.deadline, "Expired");
    require(verifySignature(intent), "Invalid sig");

    // ❌ Bug : pas de slippage protection cross-chain
    uint256 amountOut = swap(intent.tokenIn, intent.tokenOut, intent.amountIn);
    require(amountOut >= intent.minAmountOut, "Slippage");

    tokenOut.transfer(intent.user, amountOut);
}

Exploit : l'attaquant a frontrun les intents en :