Cours Blockchain et Web3 · Module 12: Security & Audit
Sécurité des Smart Contracts
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. Une reentrancy attack consiste à :
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) :
Exercices après cette leçon
- QuestionQuiz : Reentrancy
- QuestionQuiz : Front-running
- QuestionQuiz : Oracle Manipulation
- QuestionQuiz : Signature Replay
- Exercice de codePratique : Test dans Hardhat
- Exercice de codePratique : Modifier onlyOwner
- Exercice de codePratique : ReentrancyGuard
- Exercice de codePratique : Safe Math
- Exercice de codePratique : Access Control Roles
- Remets dans l'ordreTri : Audit Flow
- Remets dans l'ordreTri : Incident Response
- Remets dans l'ordreTri : Testing Pipeline
- QuestionQuiz : Checks-Effects-Interactions
- QuestionQuiz : delegatecall
- QuestionQuiz : selfdestruct
- Exercice de codePratique : Pausable Pattern
- Exercice de codePratique : Pull over Push
- Exercice de codePratique : Checks-Effects-Interactions
- Exercice de codePratique : Safe Transfer
- Exercice de codePratique : Event Logging pour la Security
- Remets dans l'ordreTri horizontal : require Statement
- Remets dans l'ordreTri horizontal : Modifier Pattern
- Remets dans l'ordreTri horizontal : SafeERC20 Usage
- Clique dans l'ordreClic : Security Checklist
- Clique dans l'ordreClic : Test Structure
- Clique dans l'ordreClic : Emergency Response Priority
- QuestionQuiz : nonReentrant
- QuestionQuiz : Hardhat vs Foundry
- QuestionQuiz : Slither
- Remets dans l'ordreTri : Vulnerability Disclosure
- Remets dans l'ordreTri : Smart Contract Upgrade
- Remets dans l'ordreTri : Pre-Deploy Checklist
- Remets dans l'ordreTri horizontal : ReentrancyGuard
- Remets dans l'ordreTri horizontal : Access Control Modifier
- Clique dans l'ordreClic : Pre-Deploy Checklist Items
- Clique dans l'ordreClic : Code Review Priorities
- QuestionQuiz : Access Control
- QuestionQuiz : Integer Overflow
- QuestionQuiz : OpenZeppelin
- QuestionQuiz : visibilité private
- QuestionQuiz : Audit
- QuestionQuiz : Bug Bounty
- QuestionQuiz : Pausable
- Projet à envoyerEnvoie ton projet au mentor
- DialogueFin du cours Web3