sécurité-amm-defi

Sécurité AMM DeFi

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

Quand l'utiliser

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

Comment ça marche

Utilisez ceci comme une bibliothèque de liste de contrôle et de schémas. Examinez chaque point d'entrée utilisateur selon les catégories ci-dessous et préférez les exemples robustes aux variantes artisanales.

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 jamais de noms de contrat non fiables, de chemins, d'URL RPC, de clés privées ou de drapeaux fournis par l'utilisateur dans les commandes shell. Demandez avant d'installer des outils ou d'exécuter des jobs longs de fuzzing/analyse statique 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ûr :

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 donation ou inflation

Utiliser directement token.balanceOf(address(this)) pour les calculs de parts permet aux attaquants de manipuler le dénominateur en envoyant des jetons 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ûr
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 jetons réellement reçus.

Manipulation d'oracle

Les prix spot sont manipulables par flash-loans. Préférez 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 glissement

Chaque chemin d'échange a besoin d'un glissement 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, "Glissement dépassé");
    _executeSwap(amountIn, amountOut);
}

Calculs de réserves sécurisés

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

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

Pour les calculs de grandes réserves, évitez le naïf a * b / c lorsqu'un risque de débordement existe.

Contrôles d'administration

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 bloquez chaque chemin privilégié.

Liste de contrôle de sécurité

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

Outils d'audit

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

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

forge test --fuzz-runs 10000