crytic/echidnaFuzzer de contrats intelligents Ethereum
Echidna est une étrange créature qui mange des bugs et est hautement électrosensible (avec nos excuses à Jacob Stanley)
Plus sérieusement, Echidna est un programme Haskell conçu pour le fuzzing/le test basé sur les propriétés de contrats intelligents Ethereum. Il utilise des campagnes de fuzzing sophistiquées basées sur la grammaire, fondées sur une ABI de contrat pour falsifier des prédicats définis par l'utilisateur ou des assertions Solidity. 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 spécifiques.
.. et un magnifique logo artisanal haute résolution.
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 est maintenu. S'il trouve un moyen de falsifier l'invariant, il imprime la séquence d'appel qui y parvient. S'il n'y parvient pas, vous avez une certaine assurance que le contrat est sûr.
Les invariants sont exprimés sous forme de fonctions Solidity dont les noms commencent par echidna_, n'ont pas d'arguments 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 peut être trouvé 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` en ligne de commande :
* **`property`** (par défaut) : Teste les fonctions préfixées par `echidna_` qui retournent `bool`.
* **`assertion`** : Détecte les échecs d'assertion provenant de `assert()` et des helpers `assertX` de Foundry (`assertTrue`, `assertEq`, etc.).
* **`foundry`** : Exécute les tests unitaires préfixés par `test` à la Foundry et les invariants d'état préfixés par `invariant_`.
* **`overflow`** : Détecte les dépassements d'entiers (Solidity >= 0.8.0).
* **`optimization`** : Maximise la valeur de retour des fonctions préfixées par `echidna_` qui retournent `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 enregistrer 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 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 enregistrera 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 dans le corpus à l'aide du « marqueur de ligne » suivant :
* si une exécution s'est terminée par un STOPr si une exécution s'est terminée par un REVERTo si une exécution s'est terminée par une erreur de gas insuffisante si une exécution s'est terminée par toute autre erreur (division par zéro, échec d'assertion, etc.)Echidna peut tester des contrats compilés avec différents systèmes de construction de contrats intelligents, notamment Foundry, Hardhat et Truffle, en utilisant crytic-compile. Pour invoquer Echidna avec le framework de compilation actuel, utilisez echidna ..
De plus, Echidna prend en charge deux modes de test des contrats complexes. Premièrement, on peut tirer parti de l'état du réseau existant et l'utiliser comme état de base pour Echidna. Deuxièmement, Echidna peut appeler n'importe quel contrat avec une ABI connue en passant le code source Solidity correspondant dans la CLI. Utilisez allContracts: true dans votre configuration pour activer cette fonctionnalité.
Notre dépôt Building Secure Smart Contracts contient un cours accéléré sur Echidna, comprenant des exemples, des leçons et des exercices.
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 pour les instructions d'utilisation et des exemples.
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 se trouve à [tests/solidity/basic/default.yaml](https://github.com/crytic/echidna/blob/HEAD/tests/solidity/basic/default.yaml). Voir 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 par défaut `text`, un pilote `json`, et un pilote `none`, qui devrait 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 dictionnaire décrivant certains appels augmentant la couverture. Ces interfaces sont sujettes à changement pour être légèrement plus conviviales ultérieurement. testType sera l'un de property, assertion, optimization, exploration ou call, et status prend toujours l'une des valeurs fuzzing, shrinking, solved, passed ou error.
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 le 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 utilisent le plus de CPU et de mémoire.
Si le profilage de base ne suffit pas, vous pouvez utiliser des [techniques de profilage avancées](https://haskell.foundation/hs-opt-handbook.github.io/src/Measurement_Observation/Haskell_Profiling/eventlog.html).
Causes courantes des problèmes de performance que nous avons observés :
- Fonctions coûteuses appelées dans les chemins chauds
- Constructeurs de données paresseux qui accumulent des closures (thunks)
- Structures de données inefficaces utilisées dans les chemins chauds
Vérifier ces points est un bon point de départ. Si vous soupçonnez qu'un calcul est trop paresseux et fuit de la mémoire, vous pouvez utiliser `force` de `Control.DeepSeq` pour garantir son évaluation.
## 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 bogues dans notre code. Nous les listons ici avec leur ticket correspondant et leur statut (« ne sera pas corrigé », « en attente », « en cours de révision », « corrigé »). Les problèmes « corrigés » devraient être inclus dans la prochaine version d'Echidna.
| Description | Ticket | Statut |
| :--- | :---: | :---: |
| Le support de Vyper est limité | [#652](https://github.com/crytic/echidna/issues/652) | *ne sera pas corrigé* |
| Support limité des bibliothèques pour les tests | [#651](https://github.com/crytic/echidna/issues/651) | *ne sera pas corrigé* |
## 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 sur Linux ou MacOS, nous fournissons des binaires Linux liés statiquement construits sur Ubuntu et des binaires MacOS majoritairement statiques sur notre [page des versions](https://github.com/crytic/echidna/releases). Vous pouvez également obtenir 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 branche `master` la plus récente 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 [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 [package docker](https://github.com/orgs/crytic/packages?repo_name=echidna), qui est automatiquement construit via GitHub Actions. Le conteneur `echidna` est basé sur `ubuntu:noble` et est conçu pour être 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`) sous 200 Mo.
Notez que les images du conteneur ne sont actuellement construites que pour les systèmes x86. Leur exécution sur des appareils ARM, comme les systèmes Mac M1, n'est pas recommandée en raison de la perte de performance due à l'émulation du processeur.
Différents tags sont disponibles pour l'image du conteneur Docker :
| Tag | Construction dans le tag
|---------------|-------------
| `vx.y.z` | Construction correspondant à la version `vx.y.z`
| `latest` | Dernière version taguée d'Echidna.
| `edge` | Dernier commit de la branche par défaut.
| `testing-foo` | Construction de test basée 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 comme celle-ci. Elle mappera le répertoire courant comme `/src` dans le conteneur et vous donnera un shell où vous pourrez utiliser `echidna` :```sh
$ docker run --rm -it -v "$(pwd)":/src ghcr.io/crytic/echidna/echidna
Sinon, si vous souhaitez construire 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 le test complets de smart contracts. Vous pouvez utiliser forge, cast, anvil et chisel directement dans le conteneur :```sh
$ docker run -it -v "$(pwd)":/src echidna bash
$ forge --version $ cast --version $ anvil --version $ chisel --version
$ forge init my-project $ cd my-project $ forge build $ forge test
### Building using Stack
Si vous préférez compiler à partir des sources, utilisez [Stack](https://docs.haskellstack.org/en/stable/). `stack install` devrait construire et compiler `echidna` dans `~/.local/bin`. Vous devrez lier avec libreadline et libsecp256k1 (construite 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). Référez-vous à nos [tests CI](https://github.com/crytic/echidna/blob/HEAD/.github/scripts/install-libff.sh) pour des conseils.
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 flag `-static`. Dans ce cas, utilisez `--flag echidna:-static` pour produire un binaire lié dynamiquement.
Si vous rencontrez des erreurs de construction liées à la liaison, essayez de modifier `--extra-include-dirs` et `--extra-lib-dirs`.
### Building using Nix (works natively on Apple M1 systems)
[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, ce qui suit permettra de compiler Echidna dans 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
## 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)
### Revues de sécurité
Les revues de sécurité publiques suivantes 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é découvertes par Echidna. Si vous avez découvert 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 une commande ne peut pas être exécutée, alors elle ne peut pas être annulée | Oct 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Si une commande peut être partiellement exécutée avec zéro, alors elle peut être partiellement exécutée avec un jeton | Oct 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | La fonction cobbdouglas ne se 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 des jetons de pool gratuits avec joinPool | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | L'appel à joinPool-exitPool ne conduit pas à des jetons de pool gratuits | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | L'appel à exitswapExternAmountOut ne conduit pas à des actifs gratuits | Jan 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [La fermeture des 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) | Déc 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) | Déc 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Le rachat initial peut se revert de manière inattendue | Déc 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Un rachat sans rachats peut tout de même retourner un succès | Déc 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Les utilisateurs sont autorisés à transférer plus de jetons 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 jetons est imprécis | Août 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 à quelle vitesse 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
|--|--
[Utilisation des outils d'analyse automatique avec les contrats MakerDAO](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)
[Bogue de précision entière dans 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)
[Apprendre le fuzzing à partir de l'exécution symbolique avec application aux contrats intelligents](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 : Un fuzzer greybox pour contrats intelligents](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 : Fuzzing multicœur diversifié de contrats intelligents](https://agroce.github.io/issta21.pdf) | [ISSTA 2021](https://conf.researchr.org/home/issta-2021) | Juillet 2021 |
| [Echidna : Un fuzzing efficace, utilisable et rapide pour les contrats intelligents](https://agroce.github.io/issta20.pdf) | [ISSTA 2020](https://conf.researchr.org/home/issta-2020) | Juillet 2020 |
| [Echidna : Un fuzzer pratique pour contrats intelligents](https://github.com/trailofbits/publications/blob/master/papers/echidna_fc_poster.pdf) | [FC 2020](https://fc20.ifca.ai/program.html) | Fév 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 à vous rendre 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 [invariants Echidna](https://github.com/crytic/echidna/blob/HEAD/tests/solidity/basic/flags.sol) simples.
* Envisagez de [contacter par e-mail](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é selon les termes de la [licence AGPLv3](https://github.com/crytic/echidna/blob/master/LICENSE).