crytic/echidnaFuzzer per smart contract Ethereum
Echidna è una strana creatura che mangia bug ed è altamente elettrosensibile (con scuse a Jacob Stanley)
Più seriamente, Echidna è un programma Haskell progettato per il fuzzing/property-based testing di smart contract Ethereum. Utilizza sofisticate campagne di fuzzing basate su grammatiche a partire da un contratto ABI per falsificare predicati definiti dall'utente o asserzioni di Solidity. Abbiamo progettato Echidna con modularità in mente, in modo che possa essere facilmente esteso per includere nuove mutazioni o testare contratti specifici in casi specifici.
.. e un bellissimo logo artigianale ad alta risoluzione.
La funzionalità principale di Echidna è un eseguibile chiamato echidna, che prende in input un contratto e una lista di invarianti (proprietà che dovrebbero rimanere sempre vere). Per ogni invariante, genera sequenze casuali di chiamate al contratto e verifica se l'invariante è soddisfatta. Se riesce a trovare un modo per falsificare l'invariante, stampa la sequenza di chiamate che lo fa. Se non ci riesce, hai una certa garanzia che il contratto sia sicuro.
Le invarianti sono espresse come funzioni Solidity con nomi che iniziano con echidna_, non hanno argomenti e restituiscono un booleano. Ad esempio, se hai una variabile balance che non dovrebbe mai scendere sotto 20, puoi scrivere una funzione aggiuntiva nel tuo contratto come questa:```solidity
function echidna_check_balance() public returns (bool) {
return(balance >= 20);
}
Per verificare questi invarianti, esegui:```sh
$ echidna myContract.sol
Un esempio di contratto con test può essere trovato tests/solidity/basic/flags.sol. Per eseguirlo, dovresti eseguire:```sh $ echidna tests/solidity/basic/flags.sol
Echidna dovrebbe trovare una sequenza di chiamate che falsifichi `echidna_sometimesfalse` e dovrebbe essere impossibilitata a trovare un input falsificante per `echidna_alwaystrue`.
### Modalità di test
L'esempio precedente usa la modalità predefinita **property**, ma Echidna supporta diverse modalità di test, configurabili tramite `testMode` nel file di configurazione o `--test-mode` nella riga di comando:
* **`property`** (predefinita): Testa le funzioni con prefisso `echidna_` che restituiscono `bool`.
* **`assertion`**: Rileva fallimenti di asserzione da `assert()` e dagli helper `assertX` di Foundry (`assertTrue`, `assertEq`, ecc.).
* **`foundry`**: Esegue test unitari in stile Foundry con prefisso `test` e invarianti stateful con prefisso `invariant_`.
* **`overflow`**: Rileva overflow/underflow interi (Solidity >= 0.8.0).
* **`optimization`**: Massimizza il valore di ritorno delle funzioni con prefisso `echidna_` che restituiscono `int256` (usa lo stesso prefisso configurabile della modalità property).
* **`exploration`**: Raccoglie copertura senza verificare proprietà.
### Raccolta e visualizzazione della copertura
Dopo aver terminato una campagna, Echidna può salvare un **corpus** di copertura massimizzata in una directory speciale specificata con l'opzione di configurazione `corpusDir`. Questa directory conterrà due voci: (1) una directory chiamata `coverage` con file JSON che possono essere riprodotti da Echidna e (2) un file di testo semplice chiamato `covered.txt`, una copia del codice sorgente con annotazioni di copertura.
Se si esegue l'esempio `tests/solidity/basic/flags.sol`, Echidna salverà alcuni file di transazioni serializzate nella directory `coverage` e un file `covered.$(date +%s).txt` con le seguenti righe:```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;
}
Il nostro strumento segnala ogni traccia di esecuzione nel corpus con il seguente "line marker":
* se un'esecuzione termina con uno STOPr se un'esecuzione termina con un REVERTo se un'esecuzione termina con un errore di out-of-gase se un'esecuzione termina con qualsiasi altro errore (divisione per zero, fallimento dell'asserzione, ecc.)Echidna può testare contratti compilati con diversi sistemi di build di smart contract, tra cui Foundry, Hardhat e Truffle, utilizzando crytic-compile. Per invocare Echidna con il framework di compilazione corrente, usa echidna ..
In aggiunta, Echidna supporta due modalità di test di contratti complessi. In primo luogo, è possibile sfruttare lo stato di rete esistente e usarlo come stato base per Echidna. In secondo luogo, Echidna può chiamare qualsiasi contratto con un ABI noto passando il corrispondente sorgente Solidity nella CLI. Usa allContracts: true nella tua configurazione per attivare questa funzionalità.
Il nostro repository Building Secure Smart Contracts contiene un corso accelerato su Echidna, inclusi esempi, lezioni ed esercizi.
Esiste un'azione Echidna che può essere utilizzata per eseguire echidna come parte di un workflow di GitHub Actions. Fare riferimento al repository crytic/echidna-action per istruzioni ed esempi di utilizzo.
La CLI di Echidna può essere utilizzata per scegliere il contratto da testare e caricare un file di configurazione.```sh $ echidna contract.sol --contract TEST --config config.yaml
Il file di configurazione consente agli utenti di scegliere i parametri EVM e di generazione dei test. Un esempio di file di configurazione completo e annotato con le opzioni predefinite si trova in [tests/solidity/basic/default.yaml](https://github.com/crytic/echidna/blob/HEAD/tests/solidity/basic/default.yaml). Consultare la [documentazione](https://secure-contracts.com/program-analysis/echidna/configuration.html) per informazioni più dettagliate sulle opzioni di configurazione disponibili.
Echidna supporta tre diversi driver di output. Il driver predefinito `text`, un driver `json` e un driver `none`, che dovrebbe sopprimere tutto l'output `stdout`. Il driver JSON riporta l'intera campagna come segue.```
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 è un dict che descrive alcune chiamate che aumentano la copertura. Queste interfacce sono soggette a modifiche per diventare leggermente più intuitive in una data futura. testType sarà uno tra property, assertion, optimization, exploration, o call, e status assume sempre uno tra fuzzing, shrinking, solved, passed, o error.
Un modo per diagnosticare i problemi di performance di Echidna è eseguire echidna con la profilazione attivata. Per eseguire Echidna con la profilazione di base, aggiungi +RTS -p -s al comando originale echidna:```sh
$ nix develop # alternatively nix-shell
$ cabal --enable-profiling run echidna -- ... +RTS -p -s
$ less echidna.prof
Questo produce un file di report (`echidna.prof`) che mostra quali funzioni consumano più CPU e memoria.
Se la profilazione di base non aiuta, puoi utilizzare [tecniche di profilazione più avanzate](https://languages.oup.com/redirect?url=https://haskell.foundation/hs-opt-handbook.github.io/src/Measurement_Observation/Haskell_Profiling/eventlog.html).
Cause comuni per problemi di prestazioni che abbiamo osservato:
- Funzioni costose chiamate in percorsi critici (hot paths)
- Costruttori di dati pigri che accumulano thunk
- Strutture dati inefficienti utilizzate in percorsi critici
Verificare questi aspetti è un buon punto di partenza. Se sospetti che un calcolo sia troppo pigro e perda memoria, puoi usare `force` da `Control.DeepSeq` per assicurarti che venga valutato.
## Limiti e problemi noti
L'emulazione e il test di EVM sono difficili. Echidna ha alcune limitazioni nell'ultima versione. Alcune di queste sono ereditate da [hevm](https://github.com/argotorg/hevm) mentre altre sono il risultato di decisioni di progettazione/prestazioni o semplicemente bug nel nostro codice. Li elenchiamo qui inclusi i relativi issue e lo stato ("wont fix", "on hold", "in review", "fixed"). I problemi "fixed" dovrebbero essere inclusi nella prossima versione di Echidna.
| Descrizione | Issue | Stato |
| :--- | :---: | :---: |
| Il supporto per Vyper è limitato | [#652](https://github.com/crytic/echidna/issues/652) | *wont fix* |
| Supporto limitato delle librerie per i test | [#651](https://github.com/crytic/echidna/issues/651) | *wont fix* |
## Installazione
### Binari precompilati
Prima di iniziare, assicurati che Slither sia [installato](https://github.com/crytic/slither) (`pip3 install slither-analyzer --user`).
Se vuoi testare rapidamente Echidna su Linux o MacOS, forniamo binari Linux staticamente collegati costruiti su Ubuntu e binari MacOS per lo più statici nella nostra [pagina delle release](https://github.com/crytic/echidna/releases). Puoi anche ottenere lo stesso tipo di binari dalla nostra [pipeline CI](https://github.com/crytic/echidna/actions?query=workflow%3ACI+branch%3Amaster+event%3Apush), basta cliccare sul commit per trovare i binari per Linux o MacOS.
### Homebrew (macOS / Linux)
Se hai Homebrew installato sul tuo Mac o Linux, puoi installare Echidna e tutte le sue dipendenze (Slither, crytic-compile) eseguendo `brew install echidna`.
Puoi anche compilare e installare l'ultimo codice del branch `master` eseguendo `brew install --HEAD echidna`.
Puoi ottenere ulteriori informazioni nella pagina della [Formula Homebrew per `echidna`](https://formulae.brew.sh/formula/echidna). La formula stessa è mantenuta come parte del [repository homebrew-core](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/echidna.rb).
### Container Docker
Se preferisci utilizzare un container Docker pre-costruito, dai un'occhiata al nostro [pacchetto docker](https://github.com/orgs/crytic/packages?repo_name=echidna), che viene automaticamente costruito tramite GitHub Actions. Il container `echidna` è basato su `ubuntu:noble` ed è pensato per essere un'immagine piccola ma abbastanza flessibile per utilizzare Echidna. Fornisce una versione pre-costruita di `echidna`, così come `slither`, `crytic-compile`, `solc-select`, `nvm` e `foundry` (inclusi `forge`, `cast`, `anvil` e `chisel`) sotto i 200 MB.
Nota che le immagini del container attualmente vengono costruite solo su sistemi x86. Eseguirle su dispositivi ARM, come i sistemi Mac M1, non è consigliato a causa della perdita di prestazioni dovuta all'emulazione della CPU.
Sono disponibili diversi tag per l'immagine del container Docker:
| Tag | Costruito nel tag
|---------------|-----------------
| `vx.y.z` | Build corrispondente alla release `vx.y.z`
| `latest` | Ultima release etichettata di Echidna.
| `edge` | Commit più recente sul branch predefinito.
| `testing-foo` | Build di test basata sul branch `foo`.
Per eseguire il container con l'ultima versione di Echidna in modo interattivo, puoi usare un comando simile al seguente. Mapperà la directory corrente come `/src` all'interno del container e ti darà una shell in cui puoi usare `echidna`:```sh
$ docker run --rm -it -v "$(pwd)":/src ghcr.io/crytic/echidna/echidna
Altrimenti, se desideri compilare localmente l'ultima versione di Echidna, ti consigliamo di utilizzare Docker. All'interno di un clone di questo repository, esegui il seguente comando per creare l'immagine del container Docker:```sh $ docker build -t echidna -f docker/Dockerfile --target final-ubuntu .
Quindi, puoi eseguire l'immagine `echidna` localmente. Ad esempio, per installare solc 0.5.7 e controllare `tests/solidity/basic/flags.sol`, puoi eseguire:```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'immagine Docker include anche gli strumenti Foundry per lo sviluppo e il test completi di smart contract. È possibile utilizzare forge, cast, anvil e chisel direttamente nel contenitore:```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
### Compilare con Stack
Se preferisci compilare dal codice sorgente, usa [Stack](https://docs.haskellstack.org/en/stable/). `stack install` dovrebbe compilare e produrre `echidna` in `~/.local/bin`. Dovrai linkare contro libreadline e libsecp256k1 (compilato con recovery abilitato), che dovrebbero essere installati con il gestore di pacchetti di tua scelta. Dovrai anche installare l'ultima release di [libff](https://github.com/scipr-lab/libff). Fai riferimento ai nostri [test CI](https://github.com/crytic/echidna/blob/HEAD/.github/scripts/install-libff.sh) per una guida.
Alcune distribuzioni Linux non includono librerie statiche per alcune cose di cui Haskell ha bisogno, ad esempio Arch Linux, il che farà fallire `stack build` con errori di linking perché usiamo il flag `-static`. In tal caso, usa `--flag echidna:-static` per produrre un binario linkato dinamicamente.
Se ottieni errori di compilazione relativi al linking, prova a modificare `--extra-include-dirs` e `--extra-lib-dirs`.
### Compilare con Nix (funziona nativamente su sistemi Apple M1)
[Gli utenti di Nix](https://nixos.org/download/) possono installare l'ultima Echidna con:
nix-env -i -f https://github.com/crytic/echidna/tarball/master
$ nix-env -i -f https://github.com/crytic/echidna/tarball/master
```
Con flakes abilitato, puoi eseguire Echidna direttamente da questo repo:```sh
$ nix run github:crytic/echidna # master
$ nix run github:crytic/echidna/v2.1.1 # specific ref (tag/branch/commit)
```
Per creare una release standalone per sistemi macOS non-Nix, il seguente procedimento compilerà Echidna in un binario per lo più statico. Questo può essere utilizzato anche su sistemi Linux per produrre un binario completamente statico.```sh
$ nix build .#echidna-redistributable
```
Nix installerà automaticamente tutte le dipendenze necessarie per lo sviluppo, incluse `crytic-compile` e `solc`. Un modo rapido per iniziare a sviluppare 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
```
## Uso pubblico di Echidna
### Suite di testing delle proprietà
Questo è un elenco parziale di progetti di smart contract che utilizzano Echidna per i test:
* [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)
### Revisioni di sicurezza
Di seguito sono riportate le revisioni di sicurezza pubbliche che hanno utilizzato Echidna per scoprire vulnerabilità
- [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)
### Trofei
Le seguenti vulnerabilità di sicurezza sono state trovate da Echidna. Se hai trovato una vulnerabilità di sicurezza utilizzando il nostro strumento, invia una PR con le informazioni pertinenti.
| Progetto | Vulnerabilità | Data |
|--|--|--|
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Se un ordine non può essere evaso, non può essere annullato | Ott 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Se un ordine può essere parzialmente evaso con zero, può essere parzialmente evaso con un token | Ott 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | La funzione cobbdouglas non esegue il revert quando vengono utilizzati parametri di input validi | Ott 2019
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Un utente malintenzionato non può rubare asset da un pool pubblico | Gen 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Un utente malintenzionato non può generare pool token gratuiti con joinPool | Gen 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Chiamare joinPool-exitPool non porta a pool token gratuiti | Gen 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Chiamare exitswapExternAmountOut non porta ad asset gratuiti | Gen 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Chiudere i troves richiede di detenere l'intero importo di LUSD coniato](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dic 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [I troves possono essere rimossi in modo improprio](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dic 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Il riscatto iniziale può restituire un revert inaspettato | Dic 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Il riscatto senza rimborsi potrebbe comunque restituire successo | Dic 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Gli utenti possono trasferire più token di quanti ne abbiano | Nov 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | I saldi degli utenti possono essere superiori alla fornitura totale | Nov 2020
[Yield Protocol](https://github.com/trailofbits/publications/blob/master/reviews/YieldProtocol.pdf) | Il calcolo aritmetico per l'acquisto e la vendita di token è impreciso | Ago 2020
### Ricerca
Possiamo anche usare Echidna per riprodurre esempi di ricerca da articoli sul fuzzing di smart contract per mostrare quanto velocemente possa trovare la soluzione. Tutti questi possono essere risolti in pochi secondi o uno o due minuti su un computer portatile.
| Fonte | Codice
|--|--
[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)
### Pubblicazioni Accademiche
| Titolo del documento | Sede | Data di pubblicazione |
| --- | --- | --- |
| [echidna-parade: Diverse multicore smart contract fuzzing](https://agroce.github.io/issta21.pdf) | [ISSTA 2021](https://conf.researchr.org/home/issta-2021) | Luglio 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) | Luglio 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 |
Se stai utilizzando Echidna per lavori accademici, considera di candidarti al [Crytic $10k Research Prize](https://blog.trailofbits.com/2019/11/13/announcing-the-crytic-10k-research-prize/).
## Come ottenere aiuto
Sentiti libero di passare dal nostro canale slack #ethereum in [Empire Hacking](https://slack.empirehacking.nyc/) per ricevere aiuto sull'uso o l'estensione di Echidna.
* Inizia rivedendo questi semplici [invarianti di Echidna](https://github.com/crytic/echidna/blob/HEAD/tests/solidity/basic/flags.sol)
* Valuta di [inviare un'email](mailto:[email protected]) al team di sviluppo di Echidna per domande più dettagliate
## Licenza
Echidna è concesso in licenza e distribuito sotto la [licenza AGPLv3](https://github.com/crytic/echidna/blob/master/LICENSE).