Sécurité des AMM DeFi

Que fait Sécurité des AMM DeFi ?

Schémas de vulnérabilité critiques et implémentations robustes pour les contrats Solidity AMM, les coffres LP et les fonctions d'échange.

Quand l'utiliser

• Écrire ou auditer un contrat Solidity AMM ou un pool de liquidité
• Implémenter des flux d'échange, de dépôt, de retrait, de mint ou de burn qui détiennent des soldes de tokens
• Examiner tout contrat qui utilise token.balanceOf(address(this)) dans des calculs de parts ou de réserves
• Ajouter des fonctions de frais, de pause, de mise à jour d'oracle ou d'autres fonctions administrateur à un protocole DeFi

Comment ça marche

Utilisez ceci comme une bibliothèque de modèles et une liste de contrôle. Examinez chaque point d'entrée utilisateur par rapport aux catégories ci-dessous et préférez les exemples robustes plutôt que les variantes faites maison.

Sécurité d'exécution

Les commandes shell de cette compétence sont des exemples d'audit locaux. Exécutez-les uniquement dans un checkout de confiance ou un bac à sable jetable, et n'insérez pas de noms de contrats, chemins, URLs RPC, clés privées ou indicateurs fournis par l'utilisateur non fiables dans les commandes shell. Demandez avant d'installer des outils ou de lancer des jobs de fuzzing/analyse statique longs qui pourraient consommer des ressources locales ou payantes importantes.

N'incluez jamais de secrets, clés privées, phrases de récupération, jetons API ou identifiants de signature mainnet dans les exemples de commandes, journaux ou rapports.

Exemples

Réentrance : appliquer l'ordre CEI

Vulnérable :

function withdraw(uint256 amount) external {
    require(balances[msg.sender] >= amount);
    token.transfer(msg.sender, amount);
    balances[msg.sender] -= amount;
}

Sécurisé :

import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

using SafeERC20 for IERC20;

function withdraw(uint256 amount) external nonReentrant {
    require(balances[msg.sender] >= amount, "Insuffisant");
    balances[msg.sender] -= amount;
    token.safeTransfer(msg.sender, amount);
}

N'écrivez pas votre propre garde quand une bibliothèque robuste existe.

Attaques par don ou inflation

Utiliser directement token.balanceOf(address(this)) pour les calculs de parts permet aux attaquants de manipuler le dénominateur en envoyant des tokens au contrat en dehors du chemin prévu.

// Vulnérable
function deposit(uint256 assets) external returns (uint256 shares) {
    shares = (assets * totalShares) / token.balanceOf(address(this));
}

// Sécurisé
uint256 private _totalAssets;

function deposit(uint256 assets) external nonReentrant returns (uint256 shares) {
    uint256 balBefore = token.balanceOf(address(this));
    token.safeTransferFrom(msg.sender, address(this), assets);
    uint256 received = token.balanceOf(address(this)) - balBefore;

    shares = totalShares == 0 ? received : (received * totalShares) / _totalAssets;
    _totalAssets += received;
    totalShares += shares;
}

Suivez une comptabilité interne et mesurez les tokens réellement reçus.

Manipulation d'oracle

Les prix spot sont manipulables via des flash loans. Préférez le TWAP.

uint32[] memory secondsAgos = new uint32[](2);
secondsAgos[0] = 1800;
secondsAgos[1] = 0;
(int56[] memory tickCumulatives,) = IUniswapV3Pool(pool).observe(secondsAgos);
int24 twapTick = int24(
    (tickCumulatives[1] - tickCumulatives[0]) / int56(uint56(30 minutes))
);
uint160 sqrtPriceX96 = TickMath.getSqrtRatioAtTick(twapTick);

Protection contre le slippage

Chaque chemin d'échange a besoin d'un slippage fourni par l'appelant et d'une deadline.

function swap(
    uint256 amountIn,
    uint256 amountOutMin,
    uint256 deadline
) external returns (uint256 amountOut) {
    require(block.timestamp <= deadline, "Expiré");
    amountOut = _calculateOut(amountIn);
    require(amountOut >= amountOutMin, "Slippage dépassé");
    _executeSwap(amountIn, amountOut);
}

Mathématiques sécurisées des réserves

import {FullMath} from "@uniswap/v3-core/contracts/libraries/FullMath.sol";

uint256 result = FullMath.mulDiv(a, b, c);

Pour les grands calculs de réserves, évitez le a * b / c naïf en cas de risque de débordement.

Contrôles administrateur

import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";

contract MyAMM is Ownable2Step {
    function setFee(uint256 fee) external onlyOwner { ... }
    function pause() external onlyOwner { ... }
}

Préférez une acceptation explicite pour le transfert de propriété et verrouillez chaque chemin privilégié.

Liste de contrôle de sécurité

• Les points d'entrée exposés à la réentrance utilisent nonReentrant
• L'ordre CEI est respecté
• Les calculs de parts ne dépendent pas du balanceOf(address(this)) brut
• Les transferts ERC-20 utilisent SafeERC20
• Les dépôts mesurent les tokens réellement reçus
• Les lectures d'oracle utilisent le TWAP ou une autre source résistante à la manipulation
• Les échanges exigent amountOutMin et deadline
• Les calculs de réserves sensibles aux débordements utilisent des primitives sécurisées comme mulDiv
• Les fonctions administrateur sont protégées par contrôle d'accès
• Une pause d'urgence existe et est testée
• Une analyse statique et du fuzzing sont effectués avant la mise en production

Outils d'audit

pip install slither-analyzer
slither . --exclude-dependencies

echidna-test . --contract YourAMM --config echidna.yaml

forge test --fuzz-runs 10000