Cours Blockchain et Web3 · Module 12: Security & Audit

Sécurité des Smart Contracts

4 min de lecture ·
Dans cette leçon6

Bienvenue à la Tour de Guet ! Atlas ici. Le dernier module - et le plus important ! La sécurité dans le Web3 est cruciale, car les erreurs peuvent coûter des millions.

Pourquoi la Sécurité est-elle si Importante ?

┌─────────────────────────────────────────────────────────────────┐
│                    LES PLUS GROS HACKS WEB3                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  2016: The DAO Hack           - 60M$ (reentrancy)              │
│  2021: Poly Network           - 610M$ (access control)          │
│  2022: Ronin Bridge           - 625M$ (clé privée compromise)  │
│  2022: Wormhole               - 320M$ (validation de signature) │
│  2023: Euler Finance          - 197M$ (attaque flash loan)      │
│                                                                  │
│  Les smart contracts sont IMMUABLES                          │
│  Bug = perte permanente                                      │
│  "Code is law"                                               │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Vulnérabilités les Plus Courantes

1. Reentrancy Attack

// CODE VULNÉRABLE
contract Vulnerable {
    mapping(address => uint256) public balances;

    function withdraw() public {
        uint256 amount = balances[msg.sender];
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success);
        balances[msg.sender] = 0; // Mise à jour APRÈS l'envoi !
    }
}

// CODE SÛR (Checks-Effects-Interactions)
contract Safe {
    mapping(address => uint256) public balances;

    function withdraw() public {
        uint256 amount = balances[msg.sender];
        balances[msg.sender] = 0; // Mise à jour AVANT l'envoi
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success);
    }
}

2. Integer Overflow/Underflow

// En Solidity < 0.8.0 sans SafeMath :
uint8 x = 255;
x = x + 1; // x = 0 (overflow !)

// En Solidity >= 0.8.0 protection automatique :
uint8 x = 255;
x = x + 1; // Revert !

3. Access Control

// AUCUN CONTRÔLE D'ACCÈS
function mint(address to, uint256 amount) public {
    _mint(to, amount); // N'importe qui peut mint !
}

// AVEC CONTRÔLE D'ACCÈS
function mint(address to, uint256 amount) public onlyOwner {
    _mint(to, amount);
}

// Ou avec OpenZeppelin AccessControl
function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
    _mint(to, amount);
}

OpenZeppelin - Patterns Sûrs

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Pausable.sol";

contract SafeContract is Ownable, ReentrancyGuard, Pausable {

    function withdraw() public nonReentrant whenNotPaused {
        // Fonction sûre
    }

    function pause() public onlyOwner {
        _pause();
    }
}

Tester les Contrats

// Hardhat + Chai
import { expect } from "chai";
import { network } from "hardhat";

const { ethers } = await network.create();

describe("MyToken", function () {
  it("Should transfer tokens correctly", async function () {
    const [owner, addr1] = await ethers.getSigners();
    const Token = await ethers.getContractFactory("MyToken");
    const token = await Token.deploy(1000);

    await token.transfer(addr1.address, 100);

    expect(await token.balanceOf(addr1.address)).to.equal(100);
    expect(await token.balanceOf(owner.address)).to.equal(900);
  });

  it("Should fail if sender doesn't have enough tokens", async function () {
    const [owner, addr1] = await ethers.getSigners();
    // ...

    await expect(
      token.connect(addr1).transfer(owner.address, 1)
    ).to.be.revertedWith("Not enough tokens");
  });
});

Checklist Avant le Déploiement

┌─────────────────────────────────────────────────────────────────┐
│                    CHECKLIST DE SÉCURITÉ                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  [ ] Protection contre reentrancy (modifier nonReentrant)       │
│  [ ] Contrôle d'accès (onlyOwner, roles)                        │
│  [ ] Validation des entrées                                     │
│  [ ] Protection contre integer overflow (Solidity 0.8+)         │
│  [ ] Sécurité des appels externes (vérifier les retours)        │
│  [ ] Visibilité correcte (public/private/internal)              │
│  [ ] Events pour les changements d'état importants              │
│  [ ] Pausabilité en cas d'urgence                               │
│  [ ] Tests complets (unitaires, intégration)                    │
│  [ ] Audit professionnel (pour les grands projets)              │
│  [ ] Programme de bug bounty                                    │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Résumé Complet du Cours

Félicitations ! Tu as terminé le voyage à travers la Crypte !

Tu as appris :

  • Les fondamentaux de la blockchain
  • La cryptographie et les clés
  • Ethereum et l'EVM
  • Ethers.js
  • Les portefeuilles et transactions
  • Solidity et les smart contracts
  • ERC-20 et ERC-721
  • Les bases de la DeFi
  • La création de dApps
  • La sécurité Web3

Maintenant tu peux construire tes propres projets Web3 !

Code de cette leçon : index.js
// Vulnérabilités courantes des Smart Contracts

console.log("=== VULNÉRABILITÉS DES SMART CONTRACTS ===\n");

const vulnerabilities = {
  "Reentrancy": {
    severity: "Critical",
    description: "L'attaquant rappelle le contrat avant la mise à jour de l'état",
    example: "The DAO hack - 60M$ volés",
    prevention: "Utiliser le pattern CEI (Checks-Effects-Interactions), ReentrancyGuard"
  },

  "Integer Overflow/Underflow": {
    severity: "High",
    description: "Les opérations arithmétiques bouclent (wrap around)",
    example: "uint8(255) + 1 = 0",
    prevention: "Solidity 0.8+ a des vérifications intégrées, SafeMath pour les versions antérieures"
  },

  "Access Control": {
    severity: "Critical",
    description: "Vérifications de permissions manquantes ou incorrectes",
    example: "N'importe qui peut appeler les fonctions admin",
    prevention: "Utiliser Ownable, AccessControl d'OpenZeppelin"
  },

  "Front-running": {
    severity: "Medium",
    description: "L'attaquant voit une tx en attente et soumet sa propre tx en premier",
    example: "Sandwich attacks sur les swaps DEX",
    prevention: "Commit-reveal, mempools privés (Flashbots)"
  },

  "Oracle Manipulation": {
    severity: "High",
    description: "Manipuler les flux de prix pour exploiter les protocoles",
    example: "Flash loan + manipuler le prix Uniswap",
    prevention: "Oracles TWAP, Chainlink, sources multiples"
  },

  "Unchecked External Calls": {
    severity: "High",
    description: "Ne pas vérifier les valeurs de retour des appels externes",
    example: "Un transfer ERC20 retourne false mais est ignoré",
    prevention: "Toujours vérifier les valeurs de retour, utiliser SafeERC20"
  },

  "Denial of Service": {
    severity: "Medium",
    description: "Rendre le contrat inutilisable",
    example: "Boucles non bornées, block gas limit",
    prevention: "Limiter les itérations, pagination, pull over push"
  },

  "Signature Replay": {
    severity: "High",
    description: "Réutiliser des signatures valides",
    example: "Utiliser la même signature permit deux fois",
    prevention: "Inclure nonce, deadline, chainId"
  }
};

Object.entries(vulnerabilities).forEach(([name, data]) => {
  console.log(`${name} [${data.severity}]`);
  console.log(`   ${data.description}`);
  console.log(`   Exemple : ${data.example}`);
  console.log(`   Prévention : ${data.prevention}\n`);
});

console.log("Ressources :");
console.log("  - SWC Registry (swcregistry.io)");
console.log("  - Rekt News (rekt.news) - post-mortems de hacks");
console.log("  - Consensys Best Practices");
console.log("  - Guides Trail of Bits");

Tu as repéré une erreur dans cette leçon ?

Teste tes connaissances

Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.

  1. 1. Une reentrancy attack consiste à :

  2. 2. Le front-running dans la blockchain exploite :

Voici 2 des 17 questions de cette leçon. Réponds aux autres dans le jeu.

Tâches pratiques dans le jeu

  • Éditeur de code

    Complète le test vérifiant l'access control

  • Éditeur de code

    Écris un modifier vérifiant que msg.sender == owner

  • Éditeur de code

    Ajoute le modifier nonReentrant à la fonction

  • Éditeur de code

    Corrige le code en utilisant des opérations mathématiques sûres

  • Éditeur de code

    Implémente un système de rôles dans le contrat

  • Tri vertical

    Ordonne le processus d'un audit de sécurité professionnel :

  • Tri vertical

    Ordonne les étapes de réaction à une attaque sur un smart contract :

  • Tri vertical

    Ordonne la pyramide de tests des smart contracts (des plus fréquents aux plus rares) :

  • Éditeur de code

    Ajoute la possibilité d'arrêter le contrat en cas d'urgence

  • Éditeur de code

    Réécris le code de push payments vers pull payments

  • Éditeur de code

    Ordonne le code selon : checks → effects → interactions

  • Éditeur de code

    Réécris le code en utilisant safeTransfer/safeTransferFrom

  • Éditeur de code

    Ajoute des security events pour surveiller le contrat

  • Tri horizontal

    À quoi ressemble la syntaxe correcte de require ?

  • Tri horizontal

    Ordonne la syntaxe du modifier onlyOwner :

  • Tri horizontal

    Comment utiliser SafeERC20 pour un transfert sûr ?

  • Clique dans l'ordre

    Clique sur les éléments dans l'ordre pour construire un require avec message d'erreur :

  • Clique dans l'ordre

    Clique sur les éléments pour construire la structure d'un test dans Hardhat/Foundry :

  • Clique dans l'ordre

    Clique sur les éléments pour construire la déclaration de la fonction pause avec ses modifiers :

  • Tri vertical

    Responsible disclosure - ordonne le processus de signalement d'une vulnérabilité trouvée :

  • Tri vertical

    Ordonne le processus d'upgrade d'un contrat via proxy :

  • Tri vertical

    Ordonne la checklist avant le déploiement sur mainnet :

  • Tri horizontal

    Comment utiliser le modifier nonReentrant ?

  • Tri horizontal

    Ordonne une fonction avec contrôle d'accès :

  • Clique dans l'ordre

    Clique sur les éléments de la security checklist dans l'ordre (test → mark → testnet → mark → audit → mark) :

  • Clique dans l'ordre

    Clique dans l'ordre les priorités lors d'un code review (access control → reentrancy → math) :

  1. QuestionQuiz : Reentrancy
  2. QuestionQuiz : Front-running
  3. QuestionQuiz : Oracle Manipulation
  4. QuestionQuiz : Signature Replay
  5. Exercice de codePratique : Test dans Hardhat
  6. Exercice de codePratique : Modifier onlyOwner
  7. Exercice de codePratique : ReentrancyGuard
  8. Exercice de codePratique : Safe Math
  9. Exercice de codePratique : Access Control Roles
  10. Remets dans l'ordreTri : Audit Flow
  11. Remets dans l'ordreTri : Incident Response
  12. Remets dans l'ordreTri : Testing Pipeline
  13. QuestionQuiz : Checks-Effects-Interactions
  14. QuestionQuiz : delegatecall
  15. QuestionQuiz : selfdestruct
  16. Exercice de codePratique : Pausable Pattern
  17. Exercice de codePratique : Pull over Push
  18. Exercice de codePratique : Checks-Effects-Interactions
  19. Exercice de codePratique : Safe Transfer
  20. Exercice de codePratique : Event Logging pour la Security
  21. Remets dans l'ordreTri horizontal : require Statement
  22. Remets dans l'ordreTri horizontal : Modifier Pattern
  23. Remets dans l'ordreTri horizontal : SafeERC20 Usage
  24. Clique dans l'ordreClic : Security Checklist
  25. Clique dans l'ordreClic : Test Structure
  26. Clique dans l'ordreClic : Emergency Response Priority
  27. QuestionQuiz : nonReentrant
  28. QuestionQuiz : Hardhat vs Foundry
  29. QuestionQuiz : Slither
  30. Remets dans l'ordreTri : Vulnerability Disclosure
  31. Remets dans l'ordreTri : Smart Contract Upgrade
  32. Remets dans l'ordreTri : Pre-Deploy Checklist
  33. Remets dans l'ordreTri horizontal : ReentrancyGuard
  34. Remets dans l'ordreTri horizontal : Access Control Modifier
  35. Clique dans l'ordreClic : Pre-Deploy Checklist Items
  36. Clique dans l'ordreClic : Code Review Priorities
  37. QuestionQuiz : Access Control
  38. QuestionQuiz : Integer Overflow
  39. QuestionQuiz : OpenZeppelin
  40. QuestionQuiz : visibilité private
  41. QuestionQuiz : Audit
  42. QuestionQuiz : Bug Bounty
  43. QuestionQuiz : Pausable
  44. Projet à envoyerEnvoie ton projet au mentor
  45. DialogueFin du cours Web3