crytic/echidnaFuzzer de contrats intelligents Ethereum
# Echidna : Un fuzzer rapide pour contrats intelligents <a href="https://raw.githubusercontent.com/crytic/echidna/master/echidna.png"><img src="https://assets.kitploit.com/production/public/readmes/2659/763a0b6f546e53fe33e871cd7359ba47272d81be37527f1cceaa827256af0337.png" width="75"/></a>
Echidna est une créature étrange qui se nourrit de bugs et est hautement électrosensible (avec toutes nos excuses à Jacob Stanley)
Plus sérieusement, Echidna est un programme Haskell conçu pour le fuzzing et les tests basés sur les propriétés des contrats intelligents Ethereum. Il utilise des campagnes de fuzzing sophistiquées basées sur une grammaire et sur une [ABI de contrat](https://docs.soliditylang.org/en/develop/abi-spec.html) pour falsifier des prédicats définis par l'utilisateur ou des [assertions Solidity](https://docs.soliditylang.org/en/develop/control-structures.html#error-handling-assert-require-revert-and-exceptions). Nous avons conçu Echidna avec la modularité à l'esprit, afin qu'il puisse être facilement étendu pour inclure de nouvelles mutations ou tester des contrats spécifiques dans des cas particuliers.
## Fonctionnalités
* Génère des entrées adaptées à votre code réel
* Collecte de corpus optionnelle, mutation et guidage par couverture pour trouver des bugs plus profonds
* Propulsé par [Slither](https://github.com/crytic/slither) pour extraire des informations utiles avant la campagne de fuzzing
* Intégration du code source pour identifier quelles lignes sont couvertes après la campagne de fuzzing
* Interface terminal interactive, sortie texte uniquement ou JSON
* Minimisation automatique des cas de test pour un triage rapide
* Intégration transparente dans le flux de travail de développement
.. et [un magnifique logo artisanal en haute résolution](https://raw.githubusercontent.com/crytic/echidna/master/echidna.png).
<a href="https://i.imgur.com/saFWti4.png"><img src="https://assets.kitploit.com/production/public/readmes/2659/ec117cf17d5b4eeb75f52a3654df19ba615818f232d5e9238093cf010431fedc.png" width="650"/></a>
## Utilisation
### Exécution du lanceur de tests
La fonctionnalité principale d'Echidna est un exécutable appelé `echidna`, qui prend en entrée un contrat et une liste
d'invariants (propriétés qui doivent toujours rester vraies). Pour chaque invariant, il génère
des séquences aléatoires d'appels au contrat et vérifie si l'invariant tient. S'il parvient à trouver un moyen
de falsifier l'invariant, il affiche la séquence d'appels correspondante. S'il n'y parvient pas, vous avez une certaine
assurance que le contrat est sûr.
### Écriture d'invariants
Les invariants sont exprimés sous forme de fonctions Solidity dont les noms commencent par `echidna_`, ne prennent aucun argument et renvoient un booléen. Par exemple, si vous avez une variable `balance` qui ne doit jamais descendre en dessous de `20`, vous pouvez écrire une fonction supplémentaire dans votre contrat comme celle-ci :```solidity
function echidna_check_balance() public returns (bool) {
return(balance >= 20);
}
```
Pour vérifier ces invariants, exécutez :```sh
$ echidna myContract.sol
```
Un exemple de contrat avec des tests se trouve dans [tests/solidity/basic/flags.sol](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol). Pour l'exécuter, vous devez exécuter :```sh
$ echidna tests/solidity/basic/flags.sol
```
Echidna devrait trouver une séquence d'appels qui falsifie `echidna_sometimesfalse` et devrait être incapable de trouver une entrée falsifiante pour `echidna_alwaystrue`.
### Modes de test
L'exemple ci-dessus utilise le mode **property** par défaut, mais Echidna prend en charge plusieurs modes de test, configurés via `testMode` dans le fichier de configuration ou `--test-mode` sur la CLI :
* **`property`** (par défaut) : Teste les fonctions préfixées par `echidna_` qui renvoient un `bool`.
* **`assertion`** : Détecte les échecs d'assertion provenant de `assert()` et des helpers `assertX` de Foundry (`assertTrue`, `assertEq`, etc.).
* **`foundry`** : Exécute des tests de style Foundry, en suivant ses conventions de nommage : tests unitaires et de fuzzing préfixés par `test` (ceux préfixés par `testFail` sont censés revert) et invariants stateful préfixés par `invariant` ou `statefulFuzz`. Les fonctions préfixées par `check` et `prove` sont des points d'entrée symboliques, mais comme ce mode est une campagne de fuzzing, elles sont fuzzées comme n'importe quelle autre fonction de test.
* **`verification`** : Vérifie symboliquement chaque fonction du contrat à l'aide d'une seule transaction. Les fonctions préfixées par `check` et `prove` sont toujours utilisées comme points d'entrée.
* **`overflow`** : Détecte les dépassements/sous-dépassements d'entiers (Solidity >= 0.8.0).
* **`optimization`** : Maximise la valeur de retour des fonctions préfixées par `echidna_` qui renvoient un `int256` (utilise le même préfixe configurable que le mode property).
* **`exploration`** : Collecte la couverture sans vérifier les propriétés.
### Collecte et visualisation de la couverture
Après avoir terminé une campagne, Echidna peut sauvegarder un **corpus** maximisant la couverture dans un répertoire spécial spécifié avec l'option de configuration `corpusDir`. Ce répertoire contiendra deux entrées : (1) un répertoire nommé `coverage` avec des fichiers JSON qui peuvent être rejoués par Echidna et (2) un fichier en texte brut nommé `covered.txt`, une copie du code source avec des annotations de couverture.
Si vous exécutez l'exemple `tests/solidity/basic/flags.sol`, Echidna sauvegardera quelques fichiers de transactions sérialisées dans le répertoire `coverage` et un fichier `covered.$(date +%s).txt` avec les lignes suivantes :```text
*r | function set0(int val) public returns (bool){
* | if (val % 100 == 0)
* | flag0 = false;
}
*r | function set1(int val) public returns (bool){
* | if (val % 10 == 0 && !flag0)
* | flag1 = false;
}
```
Notre outil signale chaque trace d'exécution du corpus avec le « marqueur de ligne » suivant :
* `*` si une exécution s'est terminée par un STOP
* `r` si une exécution s'est terminée par un REVERT
* `o` si une exécution s'est terminée par une erreur out-of-gas
* `e` si une exécution s'est terminée par toute autre erreur (division par zéro, échec d'assertion, etc.)
### Prise en charge des systèmes de build de contrats intelligents
Echidna peut tester des contrats compilés avec différents systèmes de build de contrats intelligents, notamment [Foundry](https://book.getfoundry.sh/), [Hardhat](https://hardhat.org/) et [Truffle](https://archive.trufflesuite.com/), en utilisant [crytic-compile](https://github.com/crytic/crytic-compile). Pour invoquer Echidna avec le framework de compilation actuel, utilisez `echidna .`.
En outre, Echidna prend en charge deux modes de test de contrats complexes. Premièrement, on peut [tirer parti d'un état réseau existant](https://secure-contracts.com/program-analysis/echidna/advanced/state-network-forking.html) et l'utiliser comme état de base pour Echidna. Deuxièmement, Echidna peut appeler n'importe quel contrat dont l'ABI est connue en passant le code source Solidity correspondant dans la CLI. Utilisez `allContracts: true` dans votre configuration pour activer cette option.
### Cours accéléré sur Echidna
Notre dépôt [Building Secure Smart Contracts](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial) contient un cours accéléré sur Echidna, incluant des exemples, des leçons et des exercices.
### Utiliser Echidna dans un workflow GitHub Actions
Il existe une action Echidna qui peut être utilisée pour exécuter `echidna` dans le cadre d'un workflow GitHub Actions. Veuillez consulter le dépôt [crytic/echidna-action](https://github.com/crytic/echidna-action) pour les instructions d'utilisation et des exemples.
### Options de configuration
La CLI d'Echidna peut être utilisée pour choisir le contrat à tester et charger un fichier de configuration.```sh
$ echidna contract.sol --contract TEST --config config.yaml
```
Le fichier de configuration permet aux utilisateurs de choisir les paramètres EVM et de génération de tests. Un exemple de fichier de configuration complet et annoté avec les options par défaut est disponible à l'adresse
[tests/solidity/basic/default.yaml](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/default.yaml).
Consultez la [documentation](https://secure-contracts.com/program-analysis/echidna/configuration.html)
pour des informations plus détaillées sur les options de configuration disponibles.
Echidna prend en charge trois pilotes de sortie différents. Il y a le pilote `text`
par défaut, un pilote `json`, et un pilote `none`, qui doit supprimer toute
sortie `stdout`. Le pilote JSON rapporte la campagne globale comme suit.```
Campaign = {
"success" : bool,
"error" : string?,
"tests" : [Test],
"seed" : number,
"coverage" : Coverage
}
Test = {
"contract" : string,
"name" : string,
"status" : string,
"error" : string?,
"testType" : string,
"transactions" : [Transaction]?
}
Transaction = {
"contract" : string,
"function" : string,
"arguments" : [string]?,
"gas" : number,
"gasprice" : number
}
```
`Coverage` est un dict décrivant certains appels augmentant la couverture. Ces interfaces
sont susceptibles d'évoluer pour être légèrement plus conviviales à une date ultérieure. `testType`
sera l'un des suivants : `property`, `assertion`, `optimization`, `exploration` ou `call`,
et `status` prend toujours la valeur `fuzzing`, `shrinking`, `solved`, `passed` ou `error`.
### Débogage des problèmes de performance
Une façon de diagnostiquer les problèmes de performance d'Echidna est d'exécuter `echidna` avec le profilage activé.
Pour exécuter Echidna avec un profilage de base, ajoutez `+RTS -p -s` à votre commande `echidna` d'origine :```sh
$ nix develop # alternatively nix-shell
$ cabal --enable-profiling run echidna -- ... +RTS -p -s
$ less echidna.prof
```
Cela produit un fichier de rapport (`echidna.prof`), qui montre quelles fonctions consomment le plus de CPU et de mémoire.
Si le profilage de base ne suffit pas, vous pouvez utiliser des [techniques de profilage plus avancées](https://haskell.foundation/hs-opt-handbook.github.io/src/Measurement_Observation/Haskell_Profiling/eventlog.html).
Causes courantes de problèmes de performance que nous avons observées :
- Fonctions coûteuses appelées dans des chemins critiques
- Constructeurs de données paresseux qui accumulent des thunks
- Structures de données inefficaces utilisées dans des chemins critiques
Vérifier ces points est un bon point de départ. Si vous suspectez qu'un calcul est trop paresseux et
fuite de la mémoire, vous pouvez utiliser `force` de `Control.DeepSeq` pour vous assurer qu'il est évalué.
## Limitations et problèmes connus
L'émulation et les tests EVM sont difficiles. Echidna présente certaines limitations dans la dernière version. Certaines
sont héritées de [hevm](https://github.com/argotorg/hevm) tandis que d'autres résultent de
décisions de conception/performance ou simplement de bugs dans notre code. Nous les listons ici, y compris leur
problème correspondant et leur statut ("wont fix", "on hold", "in review", "fixed"). Les problèmes
"fixed" sont censés être inclus dans la prochaine version d'Echidna.
| Description | Issue | Statut |
| :--- | :---: | :---: |
| Le support de Vyper est limité | [#652](https://github.com/crytic/echidna/issues/652) | *wont fix* |
| Support limité des bibliothèques pour les tests | [#651](https://github.com/crytic/echidna/issues/651) | *wont fix* |
## Installation
### Binaires précompilés
Avant de commencer, assurez-vous que Slither est [installé](https://github.com/crytic/slither) (`pip3 install slither-analyzer --user`).
Si vous souhaitez tester rapidement Echidna sous Linux ou MacOS, nous fournissons des binaires Linux liés statiquement construits sur Ubuntu et des binaires MacOS majoritairement statiques sur notre [page de releases](https://github.com/crytic/echidna/releases). Vous pouvez également récupérer le même type de binaires depuis notre [pipeline CI](https://github.com/crytic/echidna/actions?query=workflow%3ACI+branch%3Amaster+event%3Apush), cliquez simplement sur le commit pour trouver les binaires pour Linux ou MacOS.
### Homebrew (macOS / Linux)
Si vous avez Homebrew installé sur votre machine Mac ou Linux, vous pouvez installer Echidna et toutes ses dépendances (Slither, crytic-compile) en exécutant `brew install echidna`.
Vous pouvez également compiler et installer le code de la dernière branche `master` en exécutant `brew install --HEAD echidna`
Vous pouvez obtenir plus d'informations sur la page de la [formule Homebrew `echidna`](https://formulae.brew.sh/formula/echidna). La formule elle-même est maintenue dans le cadre du [dépôt homebrew-core](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/echidna.rb)
### Conteneur Docker
Si vous préférez utiliser un conteneur Docker préconstruit, consultez notre [paquet
docker](https://github.com/orgs/crytic/packages?repo_name=echidna), qui est
construit automatiquement via GitHub Actions. Le conteneur `echidna` est basé sur
`ubuntu:noble` et se veut une image petite mais suffisamment flexible pour utiliser
Echidna. Il fournit une version préconstruite d'`echidna`, ainsi que
`slither`, `crytic-compile`, `solc-select`, `nvm` et `foundry` (incluant
`forge`, `cast`, `anvil` et `chisel`) en moins de 200 Mo.
Notez que les images de conteneur ne se construisent actuellement que sur les systèmes x86. Les exécuter
sur des appareils ARM, tels que les systèmes Mac M1, n'est pas recommandé en raison de la perte de performance
occasionnée par l'émulation CPU.
Différents tags sont disponibles pour l'image de conteneur Docker :
| Tag | Build dans le tag
|---------------|-------------
| `vx.y.z` | Build correspondant à la release `vx.y.z`
| `latest` | Dernière release taguée d'Echidna.
| `edge` | Commit le plus récent sur la branche par défaut.
| `testing-foo` | Build de test basé sur la branche `foo`.
Pour exécuter le conteneur avec la dernière version d'Echidna de manière interactive, vous pouvez utiliser
une commande similaire à la suivante. Elle mappera le répertoire courant en tant que
`/src` à l'intérieur du conteneur, et vous donnera un shell où vous pouvez utiliser
`echidna` :```sh
$ docker run --rm -it -v "$(pwd)":/src ghcr.io/crytic/echidna/echidna
```
Sinon, si vous souhaitez compiler localement la dernière version d'Echidna, nous
recommandons d'utiliser Docker. Depuis un clone de ce dépôt, exécutez la
commande suivante pour construire l'image du conteneur Docker :```sh
$ docker build -t echidna -f docker/Dockerfile --target final-ubuntu .
```
Ensuite, vous pouvez exécuter l'image `echidna` localement. Par exemple, pour installer solc
0.5.7 et vérifier `tests/solidity/basic/flags.sol`, vous pouvez exécuter :```sh
$ docker run -it -v "$(pwd)":/src echidna bash -c "solc-select install 0.5.7 && solc-select use 0.5.7 && echidna /src/tests/solidity/basic/flags.sol"
```
L'image Docker inclut également les outils Foundry pour le développement et les tests complets de contrats intelligents. Vous pouvez utiliser `forge`, `cast`, `anvil` et `chisel` directement dans le conteneur :```sh
# Run an interactive shell with Foundry tools available
$ docker run -it -v "$(pwd)":/src echidna bash
# Inside the container, you can use Foundry commands:
$ forge --version
$ cast --version
$ anvil --version
$ chisel --version
# Example: Initialize a new Foundry project
$ forge init my-project
$ cd my-project
$ forge build
$ forge test
```
### Compilation avec Stack
Si vous préférez compiler à partir des sources, utilisez [Stack](https://docs.haskellstack.org/en/stable/). `stack install` devrait compiler et construire `echidna` dans `~/.local/bin`. Vous devrez effectuer une liaison avec libreadline et libsecp256k1 (compilée avec la récupération activée), qui devraient être installées avec le gestionnaire de paquets de votre choix. Vous devez également installer la dernière version de [libff](https://github.com/scipr-lab/libff). Reportez-vous à nos [tests CI](https://github.com/crytic/echidna/blob/master/.github/scripts/install-libff.sh) pour vous guider.
Certaines distributions Linux ne fournissent pas de bibliothèques statiques pour certaines choses dont Haskell a besoin, par exemple Arch Linux, ce qui fera échouer `stack build` avec des erreurs de liaison car nous utilisons le drapeau `-static`. Dans ce cas, utilisez `--flag echidna:-static` pour produire un binaire lié dynamiquement.
Si vous rencontrez des erreurs de compilation liées à la liaison, essayez de modifier `--extra-include-dirs` et `--extra-lib-dirs`.
### Compilation avec Nix (fonctionne nativement sur les systèmes Apple M1)
Les [utilisateurs de Nix](https://nixos.org/download/) peuvent installer la dernière version d'Echidna avec :```sh
$ nix-env -i -f https://github.com/crytic/echidna/tarball/master
```
Avec les flakes activés, vous pouvez exécuter Echidna directement depuis ce dépôt :```sh
$ nix run github:crytic/echidna # master
$ nix run github:crytic/echidna/v2.1.1 # specific ref (tag/branch/commit)
```
Pour construire une version autonome pour les systèmes macOS non-Nix, la procédure suivante compilera Echidna en un binaire principalement statique. Cela peut également être utilisé sur les systèmes Linux pour produire un binaire entièrement statique.```sh
$ nix build .#echidna-redistributable
```
Nix installera automatiquement toutes les dépendances nécessaires au développement,
y compris `crytic-compile` et `solc`. Un moyen rapide de commencer à développer Echidna :```sh
$ git clone https://github.com/crytic/echidna
$ cd echidna
$ nix develop # alternatively nix-shell
[nix-shell]$ cabal run echidna
[nix-shell]$ cabal run tests
[nix-shell]$ cabal new-repl
```
### Exécution des suites de tests
`cabal run tests` est la suite Haskell, et couvre tout ce qu'Echidna fait en
processus.
Le serveur MCP est testé hors processus à la place, en démarrant une vraie campagne et
en la pilotant comme le ferait un client agent. Cette suite est en Python, et nécessite
un `echidna` dans le `$PATH` :```sh
$ pip install -r tests/mcp/requirements-test.txt
$ pytest tests/mcp -v
```
Pointez-le vers une campagne que vous avez démarrée vous-même avec `ECHIDNA_MCP_URL`, vers un
port différent avec `ECHIDNA_MCP_PORT`, ou vers un binaire spécifique avec
`ECHIDNA_BIN`. Un exemple d'agent pilotant une campagne via la même
interface se trouve dans [examples/](https://github.com/crytic/echidna/blob/master/examples/README.md).
## Utilisation publique d'Echidna
### Suites de tests de propriétés
Voici une liste partielle de projets de contrats intelligents qui utilisent Echidna pour les tests :
* [Curvance](https://github.com/curvance/Curvance-CantinaCompetition/tree/CodeFAQAndAdjustments/tests/fuzzing)
* [Primitive](https://github.com/primitivefinance/rmm-core/tree/main/contracts/crytic)
* [Uniswap-v3](https://github.com/search?q=org%3AUniswap+echidna&type=commits)
* [Balancer](https://github.com/balancer/balancer-core/tree/master/echidna)
* [MakerDAO vest](https://github.com/makerdao/dss-vest/pull/16)
* [Optimism DAI Bridge](https://github.com/makerdao/optimism-dai-bridge/blob/master/contracts/test/DaiEchidnaTest.sol)
* [WETH10](https://github.com/WETH10/WETH10/tree/main/contracts/fuzzing)
* [Yield](https://github.com/yieldprotocol/fyDai/pull/312)
* [Convexity Protocol](https://github.com/opynfinance/ConvexityProtocol/tree/dev/contracts/echidna)
* [Aragon Staking](https://github.com/aragon/staking/blob/82bf54a3e11ec4e50d470d66048a2dd3154f940b/packages/protocol/contracts/test/lib/EchidnaStaking.sol)
* [Centre Token](https://github.com/circlefin/stablecoin-evm/tree/release-2024-03-15T223309/echidna_tests)
* [Tokencard](https://github.com/tokencard/contracts/tree/master/tools/echidna)
* [Minimalist USD Stablecoin](https://github.com/usmfum/USM/pull/41)
### Audits de sécurité
Ce qui suit présente les audits de sécurité publics qui ont utilisé Echidna pour découvrir des vulnérabilités
- [Advanced Blockchain](https://github.com/trailofbits/publications/blob/master/reviews/AdvancedBlockchain.pdf)
- [Amp](https://github.com/trailofbits/publications/blob/master/reviews/amp.pdf)
- [Ampleforth](https://github.com/trailofbits/publications/blob/master/reviews/ampleforth.pdf)
- [Atlendis](https://github.com/trailofbits/publications/blob/master/reviews/2023-03-atlendis-atlendissmartcontracts-securityreview.pdf)
- [Balancer](https://github.com/trailofbits/publications/blob/master/reviews/2021-04-balancer-balancerv2-securityreview.pdf)
- [Basis](https://github.com/trailofbits/publications/blob/master/reviews/basis.pdf)
- [Dai](https://github.com/trailofbits/publications/blob/master/reviews/mc-dai.pdf)
- [Frax](https://github.com/trailofbits/publications/blob/master/reviews/FraxQ22022.pdf)
- [Liquity](https://github.com/trailofbits/publications/blob/master/reviews/LiquityProtocolandStabilityPoolFinalReport.pdf)
- [LooksRare](https://github.com/trailofbits/publications/blob/master/reviews/LooksRare.pdf)
- [Maple](https://github.com/trailofbits/publications/blob/master/reviews/2022-03-maplefinance-securityreview.pdf)
- [Optimism](https://github.com/trailofbits/publications/blob/master/reviews/2022-11-optimism-securityreview.pdf)
- [Opyn](https://github.com/trailofbits/publications/blob/master/reviews/Opyn.pdf)
- [Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf)
- [Origin](https://github.com/trailofbits/publications/blob/master/reviews/origin.pdf)
- [Paxos](https://github.com/trailofbits/publications/blob/master/reviews/paxos.pdf)
- [Primitive](https://github.com/trailofbits/publications/blob/master/reviews/Primitive.pdf)
- [RocketPool](https://github.com/trailofbits/publications/blob/master/reviews/RocketPool.pdf)
- [Seaport](https://github.com/trailofbits/publications/blob/master/reviews/SeaportProtocol.pdf)
- [Set Protocol](https://github.com/trailofbits/publications/blob/master/reviews/setprotocol.pdf)
- [Shell protocol](https://github.com/trailofbits/publications/blob/master/reviews/ShellProtocolv2.pdf)
- [Sherlock](https://github.com/trailofbits/publications/blob/master/reviews/Sherlockv2.pdf)
- [Pegasys Pantheon](https://github.com/trailofbits/publications/blob/master/reviews/pantheon.pdf)
- [TokenCard](https://github.com/trailofbits/publications/blob/master/reviews/TokenCard.pdf)
- [Uniswap](https://github.com/trailofbits/publications/blob/master/reviews/UniswapV3Core.pdf)
- [Yearn](https://github.com/trailofbits/publications/blob/master/reviews/YearnV2Vaults.pdf)
- [Yield](https://github.com/trailofbits/publications/blob/master/reviews/YieldProtocol.pdf)
- [88mph](https://github.com/trailofbits/publications/blob/master/reviews/88mph.pdf)
- [0x](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf)
### Trophées
Les vulnérabilités de sécurité suivantes ont été trouvées par Echidna. Si vous avez trouvé une vulnérabilité de sécurité à l'aide de notre outil, veuillez soumettre une PR avec les informations pertinentes.
| Projet | Vulnérabilité | Date |
|--|--|--|
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Si un ordre ne peut pas être exécuté, alors il ne peut pas être annulé | Oct 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Si un ordre peut être partiellement exécuté avec zéro, alors il peut être partiellement exécuté avec un token | Oct 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | La fonction cobbdouglas ne revert pas lorsque des paramètres d'entrée valides sont utilisés | Oct 2019
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Un attaquant ne peut pas voler des actifs d'un pool public | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Un attaquant ne peut pas générer de tokens de pool gratuits avec joinPool | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Appeler joinPool-exitPool ne conduit pas à des tokens de pool gratuits | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Appeler exitswapExternAmountOut ne conduit pas à des actifs gratuits | Jan 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [La fermeture de troves nécessite de détenir la totalité du montant de LUSD frappé](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dec 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Les troves peuvent être supprimés de manière incorrecte](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dec 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Le redeem initial peut revert de manière inattendue | Dec 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Un redeem sans redemption pourrait tout de même retourner un succès | Dec 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Les utilisateurs sont autorisés à transférer plus de tokens qu'ils n'en possèdent | Nov 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Les soldes des utilisateurs peuvent être supérieurs à l'offre totale | Nov 2020
[Yield Protocol](https://github.com/trailofbits/publications/blob/master/reviews/YieldProtocol.pdf) | Le calcul arithmétique pour l'achat et la vente de tokens est imprécis | Aug 2020
### Recherche
Nous pouvons également utiliser Echidna pour reproduire des exemples de recherche issus d'articles sur le fuzzing de contrats intelligents afin de montrer la rapidité avec laquelle il peut trouver la solution. Tous ces exemples peuvent être résolus, en quelques secondes à une ou deux minutes sur un ordinateur portable.
| Source | Code
|--|--
[Using automatic analysis tools with MakerDAO contracts](https://forum.openzeppelin.com/t/using-automatic-analysis-tools-with-makerdao-contracts/1021) | [SimpleDSChief](https://github.com/crytic/echidna/blob/master/tests/solidity/research/vera_dschief.sol)
[Integer precision bug in Sigma Prime](https://github.com/muellerberndt/sabre#example-2-integer-precision-bug) | [VerifyFunWithNumbers](https://github.com/crytic/echidna/blob/master/tests/solidity/research/solcfuzz_funwithnumbers.sol)
[Learning to Fuzz from Symbolic Execution with Application to Smart Contracts](https://files.sri.inf.ethz.ch/website/papers/ccs19-ilf.pdf) | [Crowdsale](https://github.com/crytic/echidna/blob/master/tests/solidity/research/ilf_crowdsale.sol)
[Harvey: A Greybox Fuzzer for Smart Contracts](https://arxiv.org/abs/1905.06944) | [Foo](https://github.com/crytic/echidna/blob/master/tests/solidity/research/harvey_foo.sol), [Baz](https://github.com/crytic/echidna/blob/master/tests/solidity/research/harvey_baz.sol)
### Publications académiques
| Titre de l'article | Conférence | Date de publication |
| --- | --- | --- |
| [echidna-parade: Diverse multicore smart contract fuzzing](https://agroce.github.io/issta21.pdf) | [ISSTA 2021](https://conf.researchr.org/home/issta-2021) | July 2021 |
| [Echidna: Effective, usable, and fast fuzzing for smart contracts](https://agroce.github.io/issta20.pdf) | [ISSTA 2020](https://conf.researchr.org/home/issta-2020) | July 2020 |
| [Echidna: A Practical Smart Contract Fuzzer](https://github.com/trailofbits/publications/blob/master/papers/echidna_fc_poster.pdf) | [FC 2020](https://fc20.ifca.ai/program.html) | Feb 2020 |
Si vous utilisez Echidna pour des travaux académiques, envisagez de postuler au [Crytic $10k Research Prize](https://blog.trailofbits.com/2019/11/13/announcing-the-crytic-10k-research-prize/).
## Obtenir de l'aide
N'hésitez pas à passer sur notre canal Slack #ethereum dans [Empire Hacking](https://slack.empirehacking.nyc/) pour obtenir de l'aide sur l'utilisation ou l'extension d'Echidna.
* Commencez par examiner ces simples [invariants Echidna](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol)
* Envisagez d'[envoyer un email](mailto:[email protected]) directement à l'équipe de développement d'Echidna pour des questions plus détaillées
## Licence
Echidna est sous licence et distribué sous la [licence AGPLv3](https://github.com/crytic/echidna/blob/master/LICENSE).