crytic/echidnaFuzzer per smart contract Ethereum
# Echidna: Un Fuzzer Veloce per Smart Contract <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 è una strana creatura che mangia bug ed è altamente elettrosensibile (con le scuse a Jacob Stanley)
Più seriamente, Echidna è un programma Haskell progettato per il fuzzing/testing basato su proprietà di smart contract Ethereum. Utilizza sofisticate campagne di fuzzing basate su grammatica su un [contract ABI](https://docs.soliditylang.org/en/develop/abi-spec.html) per falsificare predicati definiti dall'utente o [asserzioni Solidity](https://docs.soliditylang.org/en/develop/control-structures.html#error-handling-assert-require-revert-and-exceptions). Abbiamo progettato Echidna con la modularità in mente, così può essere facilmente esteso per includere nuove mutazioni o testare contratti specifici in casi specifici.
## Caratteristiche
* Genera input su misura per il tuo codice effettivo
* Raccolta opzionale del corpus, mutazione e guida alla copertura per trovare bug più profondi
* Basato su [Slither](https://github.com/crytic/slither) per estrarre informazioni utili prima della campagna di fuzzing
* Integrazione del codice sorgente per identificare quali righe sono coperte dopo la campagna di fuzzing
* Interfaccia terminale interattiva, output solo testo o JSON
* Minimizzazione automatica dei casi di test per un triage rapido
* Integrazione senza soluzione di continuità nel flusso di lavoro di sviluppo
.. e [un bellissimo logo artigianale ad alta risoluzione](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>
## Utilizzo
### Esecuzione del test runner
La funzionalità principale di Echidna è un eseguibile chiamato `echidna`, che prende un contratto e una lista
di invarianti (proprietà che dovrebbero rimanere sempre vere) come input. Per ogni invariante, genera
sequenze casuali di chiamate al contratto e verifica se l'invariante è valida. 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.
### Scrivere invarianti
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 extra nel tuo contratto come questa:```solidity
function echidna_check_balance() public returns (bool) {
return(balance >= 20);
}
```
Per verificare queste invarianti, eseguire:```sh
$ echidna myContract.sol
```
Un esempio di contratto con test può essere trovato in [tests/solidity/basic/flags.sol](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol). Per eseguirlo, dovresti eseguire:```sh
$ echidna tests/solidity/basic/flags.sol
```
Echidna dovrebbe trovare una sequenza di chiamate che falsifica `echidna_sometimesfalse` e non dovrebbe essere in grado di trovare un input falsificante per `echidna_alwaystrue`.
### Modalità di test
L'esempio sopra utilizza la modalità predefinita **property**, ma Echidna supporta diverse modalità di test, configurate tramite `testMode` nel file di configurazione o `--test-mode` sulla CLI:
* **`property`** (predefinita): Testa le funzioni con prefisso `echidna_` che restituiscono `bool`.
* **`assertion`**: Rileva i fallimenti delle asserzioni da `assert()` e dagli helper `assertX` di Foundry (`assertTrue`, `assertEq`, ecc.).
* **`foundry`**: Esegue test in stile Foundry, seguendo le sue convenzioni di denominazione: test unitari e fuzz con prefisso `test` (quelli con prefisso `testFail` devono revertire) e invarianti stateful con prefisso `invariant` o `statefulFuzz`. Le funzioni con prefisso `check` e `prove` sono punti di ingresso simbolici, ma poiché questa modalità è una campagna di fuzzing, vengono sottoposte a fuzzing come qualsiasi altra funzione di test.
* **`verification`**: Verifica simbolicamente ogni funzione del contratto utilizzando una singola transazione. Le funzioni con prefisso `check` e `prove` vengono sempre utilizzate come punti di ingresso.
* **`overflow`**: Rileva overflow/underflow di interi (Solidity >= 0.8.0).
* **`optimization`**: Massimizza il valore di ritorno delle funzioni con prefisso `echidna_` che restituiscono `int256` (utilizza lo stesso prefisso configurabile della modalità property).
* **`exploration`**: Raccoglie la copertura senza verificare le proprietà.
### Raccolta e visualizzazione della copertura
Al termine di una campagna, Echidna può salvare un **corpus** che massimizza la copertura in una directory speciale specificata con l'opzione di configurazione `corpusDir`. Questa directory conterrà due voci: (1) una directory denominata `coverage` con file JSON che possono essere riprodotti da Echidna e (2) un file di testo semplice denominato `covered.txt`, una copia del codice sorgente con annotazioni di copertura.
Se esegui 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 contrassegna ogni traccia di esecuzione nel corpus con il seguente "marcatore di riga":
* `*` se un'esecuzione è terminata con uno STOP
* `r` se un'esecuzione è terminata con un REVERT
* `o` se un'esecuzione è terminata con un errore out-of-gas
* `e` se un'esecuzione è terminata con qualsiasi altro errore (divisione per zero, fallimento di un'asserzione, ecc.)
### Supporto per i sistemi di build dei contratti intelligenti
Echidna può testare contratti compilati con diversi sistemi di build per contratti intelligenti, tra cui [Foundry](https://book.getfoundry.sh/), [Hardhat](https://hardhat.org/) e [Truffle](https://archive.trufflesuite.com/), utilizzando [crytic-compile](https://github.com/crytic/crytic-compile). Per invocare Echidna con il framework di compilazione corrente, usa `echidna .`.
Inoltre, Echidna supporta due modalità per testare contratti complessi. In primo luogo, si può [sfruttare lo stato di rete esistente](https://secure-contracts.com/program-analysis/echidna/advanced/state-network-forking.html) e usarlo come stato di 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 attivarlo.
### Corso intensivo su Echidna
Il nostro repository [Building Secure Smart Contracts](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial) contiene un corso intensivo su Echidna, inclusi esempi, lezioni ed esercizi.
### Utilizzo di Echidna in un workflow di GitHub Actions
Esiste un'action di Echidna che può essere utilizzata per eseguire `echidna` come parte di un
workflow di GitHub Actions. Fai riferimento al
repository [crytic/echidna-action](https://github.com/crytic/echidna-action) per
le istruzioni d'uso e gli esempi.
### Opzioni di configurazione
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 di generazione EVM e di test. Un esempio di file di configurazione completo e annotato con le opzioni predefinite è disponibile in
[tests/solidity/basic/default.yaml](https://github.com/crytic/echidna/blob/master/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. C'è il driver predefinito `text`,
un driver `json` e un driver `none`, che dovrebbe sopprimere tutto
l'output su `stdout`. Il driver JSON riporta la campagna complessiva 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ù user-friendly in una data successiva. `testType`
sarà uno tra `property`, `assertion`, `optimization`, `exploration`, o `call`,
e `status` assume sempre uno tra `fuzzing`, `shrinking`, `solved`, `passed`, o `error`.
### Debugging Performance Problems
Un modo per diagnosticare i problemi di performance di Echidna è eseguire `echidna` con il profiling attivo.
Per eseguire Echidna con il profiling di base, aggiungi `+RTS -p -s` al tuo comando `echidna` originale:```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 occupano la maggior parte dell'utilizzo di CPU e memoria.
Se il profiling di base non aiuta, puoi utilizzare [tecniche di profiling più avanzate](https://haskell.foundation/hs-opt-handbook.github.io/src/Measurement_Observation/Haskell_Profiling/eventlog.html).
Cause comuni di problemi di prestazioni che abbiamo osservato:
- Funzioni costose chiamate in percorsi critici
- Costruttori di dati lazy che accumulano thunk
- Strutture dati inefficienti utilizzate in percorsi critici
Verificare questi aspetti è un buon punto di partenza. Se sospetti che qualche calcolo sia troppo lazy e
perda memoria, puoi usare `force` da `Control.DeepSeq` per assicurarti che venga valutato.
## Limitazioni e problemi noti
L'emulazione e il testing di EVM sono difficili. Echidna presenta alcune limitazioni nell'ultima release. Alcune di
queste sono ereditate da [hevm](https://github.com/argotorg/hevm) mentre altre sono il risultato di
decisioni di design/prestazioni o semplicemente bug nel nostro codice. Le elenchiamo qui includendo il
relativo issue e lo stato ("wont fix", "on hold", "in review", "fixed"). Gli issue che sono
"fixed" ci si aspetta che siano inclusi nella prossima release di Echidna.
| Description | Issue | Status |
| :--- | :---: | :---: |
| Il supporto a Vyper è limitato | [#652](https://github.com/crytic/echidna/issues/652) | *wont fix* |
| Supporto limitato delle librerie per il testing | [#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 linkati compilati su Ubuntu e binari MacOS per lo più statici sulla nostra [pagina delle release](https://github.com/crytic/echidna/releases). Puoi anche scaricare 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 sulla tua macchina Mac o Linux, puoi installare Echidna e tutte le sue dipendenze (Slither, crytic-compile) eseguendo `brew install echidna`.
Puoi anche compilare e installare il codice più recente del branch `master` eseguendo `brew install --HEAD echidna`
Puoi ottenere ulteriori informazioni nella pagina della [Formula Homebrew `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
costruito automaticamente tramite GitHub Actions. Il container `echidna` è basato su
`ubuntu:noble` ed è pensato per essere un'immagine piccola ma sufficientemente 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 è raccomandato a causa della perdita di prestazioni
causata dall'emulazione della CPU.
Diversi tag sono disponibili per l'immagine del container Docker:
| Tag | Build nel tag
|---------------|-------------
| `vx.y.z` | Build corrispondente alla release `vx.y.z`
| `latest` | Ultima release taggata di Echidna.
| `edge` | Commit più recente sul branch predefinito.
| `testing-foo` | Build di testing basata sul branch `foo`.
Per eseguire il container con l'ultima versione di Echidna in modo interattivo, puoi usare
qualcosa come il seguente comando. Mapperà la directory corrente come
`/src` all'interno del container, e ti fornirà una shell dove puoi usare
`echidna`:```sh
$ docker run --rm -it -v "$(pwd)":/src ghcr.io/crytic/echidna/echidna
```
Altrimenti, se vuoi compilare localmente l'ultima versione di Echidna, ti
consigliamo di usare Docker. All'interno di un clone di questo repository, esegui il
seguente comando per compilare l'immagine del container Docker:```sh
$ docker build -t echidna -f docker/Dockerfile --target final-ubuntu .
```
Poi, puoi eseguire localmente l'immagine `echidna`. Ad esempio, per installare solc
0.5.7 e verificare `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 completo di smart contract. Puoi utilizzare `forge`, `cast`, `anvil` e `chisel` direttamente nel container:```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
```
### Compilazione tramite Stack
Se preferisci compilare dai sorgenti, usa [Stack](https://docs.haskellstack.org/en/stable/). `stack install` dovrebbe compilare e installare `echidna` in `~/.local/bin`. Dovrai collegarti a libreadline e libsecp256k1 (compilata con il supporto al recovery abilitato), che dovrebbero essere installate con il gestore di pacchetti che preferisci. Devi 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/master/.github/scripts/install-libff.sh) per una guida.
Alcune distribuzioni Linux non forniscono librerie statiche per certe cose di cui Haskell ha bisogno, ad esempio Arch Linux, il che causerà il fallimento di `stack build` con errori di linking perché usiamo il flag `-static`. In quel caso, usa `--flag echidna:-static` per produrre un binario collegato dinamicamente.
Se ricevi errori di compilazione relativi al linking, prova a smanettare con `--extra-include-dirs` e `--extra-lib-dirs`.
### Compilazione tramite Nix (funziona nativamente su sistemi Apple M1)
Gli [utenti Nix](https://nixos.org/download/) possono installare l'ultima versione di Echidna con:```sh
$ nix-env -i -f https://github.com/crytic/echidna/tarball/master
```
Con i flakes abilitati, puoi eseguire Echidna direttamente da questo repository:```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, quanto segue
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 richieste per lo sviluppo
inclusi `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
```
### Esecuzione delle suite di test
`cabal run tests` è la suite Haskell, e copre tutto ciò che Echidna fa in
processo.
Il server MCP viene invece testato fuori processo, avviando una campagna reale e
pilotandola come farebbe un client agente. Quella suite è in Python, e necessita di un
`echidna` nel `$PATH`:```sh
$ pip install -r tests/mcp/requirements-test.txt
$ pytest tests/mcp -v
```
Indicalo verso una campagna che hai avviato tu stesso con `ECHIDNA_MCP_URL`, verso una
porta diversa con `ECHIDNA_MCP_PORT`, o verso un binario specifico con
`ECHIDNA_BIN`. Un esempio di un agente che guida una campagna attraverso la stessa
interfaccia è in [examples/](https://github.com/crytic/echidna/blob/master/examples/README.md).
## Uso pubblico di Echidna
### Suite di property testing
Questa è una lista parziale di progetti di smart contract che usano 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)
### Security review
Quanto segue mostra le security review 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 usando il nostro strumento, invia una PR con le informazioni rilevanti.
| Progetto | Vulnerabilità | Data |
|--|--|--|
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Se un ordine non può essere eseguito, allora 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 eseguito con zero, allora può essere parzialmente eseguito 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 usati parametri di input validi | Ott 2019
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Un attaccante non può rubare asset da un pool pubblico | Gen 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Un attaccante 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 le trove richiede di detenere l'intero ammontare 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) | [Le trove possono essere rimosse 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 redeem iniziale può eseguire il revert inaspettatamente | Dic 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Redeem senza redemption potrebbe comunque restituire successo | Dic 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Agli utenti è consentito trasferire più token di quanti ne possiedano | Nov 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | I saldi degli utenti possono essere maggiori della supply 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 tratti da paper sul fuzzing di smart contract, per mostrare quanto rapidamente riesca a trovare la soluzione. Tutti questi possono essere risolti, in pochi secondi fino a 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 paper | 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 usando Echidna per lavoro accademico, considera di candidarti al [Crytic $10k Research Prize](https://blog.trailofbits.com/2019/11/13/announcing-the-crytic-10k-research-prize/).
## Ottenere aiuto
Passa pure dal nostro canale slack #ethereum in [Empire Hacking](https://slack.empirehacking.nyc/) per assistenza sull'uso o sull'estensione di Echidna.
* Inizia rivedendo queste semplici [invarianti di Echidna](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol)
* Considera di [inviare un'email](mailto:[email protected]) direttamente 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).