delete groups[id] remet l'admin à zéro. Mais tous les membres du groupe sont toujours là.
Un mapping ne connaît pas ses clés : l'EVM n'a aucun moyen de savoir quels slots effacer. Donc delete sur une struct saute ses membres mapping. Pas d'erreur, pas de warning.
Ici, l'admin ferme le groupe 42. N'importe qui le recrée avec le même id… et hérite de tous les anciens membres : isMember(42, ancien) renvoie toujours true.
Les parades :
- ne jamais réutiliser un id (compteur qui ne fait que monter)
- ou versionner : un nonce par groupe, incrémenté à la fermeture, qui entre dans la clé (isMember[nonce][user])
- ou garder la liste des clés si tu dois vraiment tout effacer, en acceptant un coût en gas linéaire
Règle à retenir : en stockage, "supprimé" ne veut jamais dire "vide" dès qu'un mapping est dans la struct.
#Solidity
Un vault qui garde des NFT en dépôt. Le principe est simple : tu envoies ton NFT avec safeTransferFrom, le contrat enregistre que tu l'as déposé, et toi seul peux le récupérer avec withdraw.
Une seule collection acceptée, fixée au déploiement. Pas de proxy, pas d'oracle, pas de calcul de prix, pas d'ether en jeu. Le withdraw efface l'entrée avant le transfert, et le require compare bien le déposant à l'appelant.
Pourtant, un attaquant peut repartir avec n'importe quel NFT déposé dans ce contrat. Il n'a besoin d'aucun NFT de la collection, d'aucune signature, d'aucune complicité. Il paie seulement le gas.
Ton exercice :
- trouve ce qui rend le vol possible ;
- décris la suite exacte d'appels de l'attaquant ;
- propose la correction minimale, en une ligne.
Réponds en commentaire avec ton raisonnement, pas seulement le nom de la faille. La solution détaillée sera publiée sous ce post dans 24 h.
#Solidity #SmartContract #SécuritéWeb3 #AuditSmartContract #NFT
Mêmes 4 octets, même conversion vers 1 octet, deux résultats différents.
Tu veux extraire un octet d'un bytes4, par exemple pour lire un sélecteur ou décoder un champ compacté. Tu passes par bytes1(...) ou par uint8(...). Ça paraît équivalent. Ça ne l'est pas.
Dans le code ci-dessus :
- sel vaut 0x12345678
- n est le même motif de bits, vu comme un uint32
- a, b et c tronquent chacun la valeur sur 1 octet
La question : que renvoie f() ?
Donne a, b et c (b en décimal).
Indice : la conversion explicite ne garde pas le même côté selon la famille de types.
Ta réponse en commentaire 👇
#Solidity #Ethereum
USDC et USDT ont 6 décimales, WBTC 8, DAI 18. Additionner des montants bruts de tokens différents, c'est mélanger des unités sans rapport.
Dans depositBad, 100 USDC arrivent sous la forme 1e8. Le contrat les crédite tels quels dans un solde exprimé en 18 décimales : l'utilisateur reçoit 0,0000000001 « dollar ». 100 DAI, eux, valent 1e20. Même valeur réelle, écart de 10^12 dans la comptabilité.
En test, avec un mock à 18 décimales, tout passe. En production, ça donne des seuils minimum inatteignables, des parts mal calculées, des ratios de collatéral faux.
La correction : fixer une unité interne (ici 18 décimales) et convertir chaque montant à l'entrée avec decimals(). Un token à plus de 18 décimales fait revert la soustraction : c'est voulu.
Réflexe d'audit : dès que deux montants de tokens différents sont additionnés ou comparés, cherche où se fait la normalisation.
#Solidity #SmartContract #DeFi #SécuritéWeb3
Un enum, c'est un uint8 déguisé. Mais le compilateur ne te laisse pas en faire n'importe quoi.
Ce contrat fait avancer une commande d'un statut au suivant : Pending → Active → Closed.
La commande 7 n'a jamais été touchée. On envoie trois transactions séparées, l'une après l'autre :
1. advance(7)
2. advance(7)
3. advance(7)
Deux questions :
→ Laquelle de ces transactions revert, s'il y en a une ?
→ Que renvoie statusOf(7) après les trois ?
Lis bien la ligne de advance : le cast vers uint8, le + 1, puis le retour vers Status.
Réponds en commentaire, avec ton raisonnement.
#Solidity
Tu déclares un tableau ou une struct en public et tu penses pouvoir tout lire depuis ton front. Le getter généré par le compilateur ne renvoie pas ce que tu crois.
Deux pièges :
1. `uint256[] public ids` ne génère pas `ids()` qui renverrait le tableau entier. Tu obtiens `ids(uint256 index)`, qui renvoie un seul élément. Pour tout lire, il faut boucler côté client ou écrire un getter.
2. Le getter d'une struct publique renvoie ses champs sous forme de tuple, mais il omet sans prévenir les membres de type tableau et mapping. Ici, `pools(key)` renvoie `(owner, name)`. `weights` disparaît de l'ABI, sans warning. Seuls `string` et `bytes` sont conservés.
La parade : écris un getter explicite qui renvoie `uint256[] memory` ou la struct complète en `memory`. Depuis 0.8, l'ABI coder v2 est actif par défaut, et retourner une struct avec des champs dynamiques fonctionne.
Avant d'intégrer un contrat, relis son ABI, pas seulement son code source.
#Solidity #Ethereum
Un pool de prêt en ETH, trois fonctions : deposit, withdraw et flashLoan.
Les prêteurs déposent de l'ether et le récupèrent quand ils veulent. Entre-temps, n'importe quel contrat peut emprunter la trésorerie du pool le temps d'une transaction, à condition de tout rendre avant la fin de l'appel.
Le withdraw remet le solde à zéro avant l'envoi. Le flashLoan vérifie le remboursement avant de rendre la main. Le compilateur ne signale rien et les tests unitaires de base passent.
Pourtant, ce contrat contient une vulnérabilité qui permet à un attaquant de vider l'intégralité du pool en deux transactions.
Ton exercice :
1. Trouve la faille.
2. Décris le scénario d'attaque, étape par étape.
3. Propose une correction.
Réponds en commentaire. La solution détaillée arrive ici dans 48 h.
#Solidity #SmartContract #SécuritéWeb3 #AuditSmartContract #DeFi
Un modifier peut contenir plusieurs fois le symbole _. Et un return dans le corps de la fonction ne fait pas forcément ce que tu crois.
Le contrat ci-dessous est tout juste déployé : count vaut 0.
On appelle d'abord bump(3), puis bump(7), dans deux transactions séparées.
Aucune des deux ne revert.
Que vaut count après le second appel ?
Indice : relis le modifier ligne par ligne, puis demande-toi jusqu'où le return de la ligne 14 fait sortir l'exécution.
Ta réponse en commentaire, avec le détail du calcul.
#Solidity
Écrire (bool ok, ) = https://t.co/D6nqZOccU0(data) n'ignore pas la donnée de retour : elle est quand même copiée dans ta mémoire.
Et c'est toi qui paies.
Un contrat cible malveillant peut faire revert(0, N) avec un N énorme. Le plafond {gas: 100_000} limite ce qu'il dépense, lui. Pas ce que tu dépenses ensuite à copier sa réponse : expansion mémoire (coût quadratique) + RETURNDATACOPY, sur ton propre budget.
C'est la "return bomb". Si ton relayer ou ton keeper doit absolument finir son travail après l'appel (émettre un event, marquer une tâche exécutée), la cible peut le faire tomber à court de gas.
La parade : appeler en assembly avec une zone de sortie de taille 0. Rien n'est copié. Si tu as besoin d'une partie de la réponse, borne la copie à quelques octets.
Appel externe vers une adresse non fiable = taille de retour non fiable.
#Solidity #Ethereum
Un délai exprimé en blocs n'est pas une durée. C'est un pari sur le temps de bloc.
Dans LockByBlocks, 50 400 blocs = 7 jours, à condition qu'il y ait un bloc toutes les 12 s comme sur Ethereum. Déploie le même contrat sur Base ou Optimism, où un bloc sort toutes les 2 s : le verrou dure environ 28 heures. Sur Arbitrum, block.number suit même les blocs L1.
Pour un timelock, un vesting ou une période de vote, cet écart est une faille de logique. Tes utilisateurs comptent sur 7 jours pour réagir, ils en ont un.
LockByTime exprime la durée en secondes avec block.timestamp et l'unité native 7 days. Le délai reste le même sur toutes les chaînes EVM, et le code se lit sans commentaire de conversion.
« Le timestamp est manipulable » ? De quelques secondes au plus. C'est négligeable à l'échelle de jours. Ça ne pose problème que si ta logique repose sur une fenêtre de quelques secondes.
Règle simple : compte en blocs ce qui concerne l'ordre des blocs, en secondes ce qui concerne le temps.
#Solidity #SmartContract #EVM #SécuritéWeb3
Une valeur absolue en une ligne et une division signée. Deux fonctions sans boucle, sans stockage, sans appel externe. Pourtant, deux des quatre appels ci-dessous font revert.
Regarde le code et trouve lesquels.
A) abs(-5)
B) abs(type(int256).min)
C) div(-128, 1)
D) div(-128, -1)
Indice : en Solidity 0.8, l'arithmétique est vérifiée. Ce contrôle ne concerne pas seulement + et *.
Réponds en commentaire avec tes lettres. Explique en une phrase pourquoi chacune revert.
#Solidity
type(I).interfaceId ignore les fonctions héritées. Si ton interface en étend une autre, son identifiant ERC-165 ne couvre que ses propres fonctions.
Avec interface IExtended is IBase, type(IExtended).interfaceId vaut le sélecteur de bar() seul. foo() n'entre pas dans le XOR.
C'est voulu : c'est la définition d'ERC-165. L'identifiant d'ERC-721, par exemple, n'inclut pas supportsInterface.
La conséquence : supportsInterface doit renvoyer true pour chaque niveau de la hiérarchie, ERC-165 compris. Un contrat qui ne déclare que IExtended répond false à qui teste IBase, et l'intégration qui vérifie IBase le rejette.
Si tu calcules l'identifiant à la main, n'ajoute pas les sélecteurs hérités. Tu obtiendrais une valeur que personne ne teste.
#Solidity #Ethereum
Un contrat d'escrow minimal. L'acheteur ouvre un deal en déposant de l'ETH. Quand la prestation est livrée, il libère les fonds vers le vendeur. Si le vendeur renonce à la vente, il rembourse l'acheteur.
Les contrôles d'accès sont en place : seul l'acheteur peut libérer, seul le vendeur peut rembourser. Les envois passent par call, leur retour est vérifié, et le stockage est modifié avant chaque transfert d'ETH.
Pourtant, ce contrat ne doit pas partir en production. Un attaquant peut en retirer plus d'ETH qu'il n'en a déposé. La différence est prélevée sur les dépôts des autres utilisateurs.
Ton exercice :
- trouve la faille ;
- écris la séquence d'appels exacte qui l'exploite, avec les adresses impliquées ;
- propose une correction minimale.
Lis chaque ligne comme si des millions d'euros étaient bloqués dans ce contrat. En audit, c'est souvent le cas.
Réponds en commentaire. L'analyse complète arrive dans 24 h.
#Solidity #SmartContract #SécuritéWeb3 #AuditSmartContract #EVM
Trois contrats parents, une seule zone de stockage. Avec l'héritage, chaque variable d'état atterrit dans un slot précis, et ce n'est pas forcément celui que tu crois.
Le code ci-dessous compile. Pas d'assembly, pas de proxy : de l'héritage multiple et quatre variables d'état.
Question : dans `Vault`, quel est le numéro du slot de stockage (0, 1, 2…) de `paused` ? Ce slot est-il partagé avec une autre variable ?
Rappels utiles : un slot fait 32 octets. Une address en occupe 20, un uint256 32, un bool 1 et un uint64 8.
Réponds en commentaire avec ton raisonnement : le numéro de slot seul ne suffit pas.
#Solidity #Ethereum
Ton DOMAIN_SEPARATOR EIP-712 calculé une fois dans le constructor ? Après un fork de la chaîne, toutes les signatures deviennent rejouables des deux côtés.
Le chainId est dans le domaine justement pour empêcher le rejeu entre chaînes. Mais si tu le figes au déploiement, il ne bouge plus.
Après un fork, ton contrat existe sur deux chaînes, à la même adresse, avec le même stockage. Le chainId a changé sur l'une des deux, pas ton separator. Une signature valide sur A l'est aussi sur B.
La parade :
- garde le separator en cache (immutable), lire block.chainid coûte peu
- compare block.chainid au chainId mis en cache
- s'ils diffèrent, recalcule le domaine
Tu paies le hash complet uniquement dans le cas rare du fork.
C'est exactement ce que fait l'implémentation EIP712 d'OpenZeppelin. Si tu écris la tienne, n'oublie pas ce test.
#Solidity #Ethereum
tx.origin désigne le compte qui a signé la transaction. msg.sender désigne l'appelant direct. Utiliser le premier pour un contrôle d'accès, c'est ouvrir la porte au phishing.
Dans WalletBad, withdraw vérifie tx.origin == owner. Un attaquant déploie un contrat dont la fonction mint() appelle WalletBad.withdraw(attaquant, solde). Il suffit que le propriétaire interagisse une fois avec ce contrat (faux airdrop, faux mint) : tx.origin vaut owner sur toute la chaîne d'appels, le check passe, le wallet est vidé.
Dans WalletGood, msg.sender vaut l'adresse du contrat malveillant. L'appel revert.
Règle simple : pour l'autorisation, msg.sender, toujours. Même l'usage parfois cité, require(tx.origin == msg.sender) pour exclure les contrats, est devenu fragile : avec EIP-7702, un EOA peut exécuter du code.
Bonus : avec msg.sender, ton contrat reste compatible avec les multisigs et les smart wallets, qui ne sont jamais tx.origin.
#Solidity #SmartContract #SécuritéWeb3 #Ethereum
Un contrat avec un receive() payable et un fallback() non payable. Trois appels bas niveau presque identiques, trois destins différents.
https://t.co/GmkQYyxP1I(router) est appelé avec msg.value = 2 wei, donc Caller a de quoi envoyer 1 wei deux fois.
Question :
que valent a, b et c ?
Et que valent receiveHits et fallbackHits après l'appel ?
Indice : demande-toi ce qui décide si l'EVM passe par receive ou par fallback. Ensuite, regarde ce qui arrive quand de l'ETH atterrit sur une fonction non payable.
Réponds en commentaire, avec une justification pour chaque appel.
#Solidity #Ethereum
ecrecover ne revert jamais. Signature invalide ? Il renvoie address(0), sans la moindre erreur.
Et si ton signer n'est pas encore configuré, il vaut… address(0).
Résultat : n'importe qui passe la vérification avec v = 0 et r, s au hasard. Le precompile échoue, ecrecover renvoie 0, et 0 == signer.
Ça arrive plus souvent qu'on le croit :
- signer défini dans un initialize jamais appelé
- setSigner oublié après le déploiement
- signer remis à zéro pour « désactiver » les claims
La parade tient en deux lignes :
- rejeter recovered == address(0) avant de comparer
- refuser address(0) dans le setter du signer
Ou passe par la lib ECDSA d'OpenZeppelin : recover revert sur une signature invalide au lieu de renvoyer 0, et rejette aussi les s malléables.
Règle simple : address(0) n'est jamais une identité valide.
#Solidity #Ethereum
Contrat du jour : une prévente de tokens réservée à une allowlist.
La liste des adresses autorisées est fixée au déploiement. Le prix est constant, le montant d'ETH est vérifié à l'unité près et les fonds partent vers l'owner via withdraw().
Les tests unitaires passent tous :
- achat valide depuis une adresse autorisée
- achat refusé hors allowlist
- montant d'ETH incorrect rejeté
- transfert entre comptes
- retrait des fonds par l'owner
Pas d'appel externe dans buy(), pas de calcul exotique, Solidity 0.8 protège contre les overflows. Sur le papier, rien à signaler.
Pourtant, ce contrat contient une vulnérabilité exploitable dès la première minute de la vente, sans outil particulier ni contrat d'attaque.
Ton défi :
1. Trouve la faille.
2. Décris le scénario d'attaque, étape par étape.
3. Propose une correction minimale.
Réponds en commentaire, même si tu n'as qu'une intuition. Prends le temps de justifier : on veut le raisonnement, pas seulement le nom de la faille.
La solution détaillée sera publiée en commentaire dans 48 h.
#Solidity #SmartContract #SécuritéWeb3 #AuditSmartContract #Ethereum
Deux mots de 4 lettres, deux longueurs différentes.
Ce contrat limite les pseudos à 4 caractères. Du moins, c'est ce que croit son auteur : il mesure la longueur avec bytes(name).length.
La fonction check() mesure deux chaînes qui ne diffèrent que par l'accent :
- "cafe"
- "caf\u00e9", c'est-à-dire "café" écrit avec un échappement Unicode
Les deux font 4 lettres à l'écran.
Question : que renvoie check() ? Donne a et b.
Bonus : avec ce résultat, un utilisateur nommé "café" peut-il s'enregistrer ?
Réponds en commentaire, avec ton raisonnement.
#Solidity