crytic/echidnaFuzzer de contratos inteligentes Ethereum
# Echidna: Um Fuzzer Rápido para Contratos Inteligentes <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 é uma criatura estranha que come bugs e é altamente eletrossensível (com desculpas a Jacob Stanley)
Mais seriamente, Echidna é um programa em Haskell projetado para fuzzing/testes baseados em propriedades de contratos inteligentes Ethereum. Ele usa campanhas sofisticadas de fuzzing baseadas em gramática, fundamentadas em uma [ABI de contrato](https://docs.soliditylang.org/en/develop/abi-spec.html), para falsificar predicados definidos pelo usuário ou [asserções Solidity](https://docs.soliditylang.org/en/develop/control-structures.html#error-handling-assert-require-revert-and-exceptions). Projetamos o Echidna com modularidade em mente, para que possa ser facilmente estendido para incluir novas mutações ou testar contratos específicos em casos específicos.
## Recursos
* Gera entradas adaptadas ao seu código real
* Coleta opcional de corpus, mutação e orientação de cobertura para encontrar bugs mais profundos
* Desenvolvido com [Slither](https://github.com/crytic/slither) para extrair informações úteis antes da campanha de fuzzing
* Integração com o código-fonte para identificar quais linhas são cobertas após a campanha de fuzzing
* Interface de terminal interativa, saída somente texto ou JSON
* Minimização automática de casos de teste para triagem rápida
* Integração perfeita no fluxo de trabalho de desenvolvimento
.. e [um belo logotipo artesanal em alta resolução](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>
## Uso
### Executando o executor de testes
A funcionalidade central do Echidna é um executável chamado `echidna`, que recebe um contrato e uma lista
de invariantes (propriedades que devem sempre permanecer verdadeiras) como entrada. Para cada invariante, ele gera
sequências aleatórias de chamadas ao contrato e verifica se a invariante se mantém. Se conseguir encontrar alguma forma
de falsificar a invariante, ele imprime a sequência de chamadas que o faz. Se não conseguir, você tem alguma
garantia de que o contrato é seguro.
### Escrevendo invariantes
As invariantes são expressas como funções Solidity com nomes que começam com `echidna_`, não têm argumentos e retornam um booleano. Por exemplo, se você tem alguma variável `balance` que nunca deve ficar abaixo de `20`, você pode escrever uma função extra no seu contrato como esta:```solidity
function echidna_check_balance() public returns (bool) {
return(balance >= 20);
}
```
Para verificar essas invariantes, execute:```sh
$ echidna myContract.sol
```
Um exemplo de contrato com testes pode ser encontrado em [tests/solidity/basic/flags.sol](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol). Para executá-lo, você deve executar:```sh
$ echidna tests/solidity/basic/flags.sol
```
O Echidna deve encontrar uma sequência de chamadas que falsifique `echidna_sometimesfalse` e deve ser incapaz de encontrar uma entrada falsificadora para `echidna_alwaystrue`.
### Modos de teste
O exemplo acima usa o modo **property** padrão, mas o Echidna suporta vários modos de teste, configurados via `testMode` no arquivo de configuração ou `--test-mode` na CLI:
* **`property`** (padrão): Testa funções com prefixo `echidna_` que retornam `bool`.
* **`assertion`**: Detecta falhas de asserção de `assert()` e dos auxiliares `assertX` do Foundry (`assertTrue`, `assertEq`, etc.).
* **`foundry`**: Executa testes no estilo Foundry, seguindo suas convenções de nomenclatura: testes unitários e de fuzz com prefixo `test` (os com prefixo `testFail` devem reverter) e invariantes stateful com prefixo `invariant` ou `statefulFuzz`. Funções com prefixo `check` e `prove` são pontos de entrada simbólicos, mas como este modo é uma campanha de fuzzing, elas são fuzzed como qualquer outra função de teste.
* **`verification`**: Verifica simbolicamente cada função do contrato usando uma única transação. Funções com prefixo `check` e `prove` são sempre usadas como pontos de entrada.
* **`overflow`**: Detecta over/underflows de inteiros (Solidity >= 0.8.0).
* **`optimization`**: Maximiza o valor de retorno de funções com prefixo `echidna_` que retornam `int256` (usa o mesmo prefixo configurável do modo property).
* **`exploration`**: Coleta cobertura sem verificar propriedades.
### Coletando e visualizando cobertura
Após finalizar uma campanha, o Echidna pode salvar um **corpus** de maximização de cobertura em um diretório especial especificado com a opção de configuração `corpusDir`. Este diretório conterá duas entradas: (1) um diretório chamado `coverage` com arquivos JSON que podem ser reproduzidos pelo Echidna e (2) um arquivo de texto simples chamado `covered.txt`, uma cópia do código-fonte com anotações de cobertura.
Se você executar o exemplo `tests/solidity/basic/flags.sol`, o Echidna salvará alguns arquivos de transações serializadas no diretório `coverage` e um arquivo `covered.$(date +%s).txt` com as seguintes linhas:```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;
}
```
Nossa ferramenta sinaliza cada traço de execução no corpus com o seguinte "marcador de linha":
* `*` se uma execução terminou com um STOP
* `r` se uma execução terminou com um REVERT
* `o` se uma execução terminou com um erro de out-of-gas
* `e` se uma execução terminou com qualquer outro erro (divisão por zero, falha de asserção, etc)
### Suporte para sistemas de build de contratos inteligentes
O Echidna pode testar contratos compilados com diferentes sistemas de build de contratos inteligentes, incluindo [Foundry](https://book.getfoundry.sh/), [Hardhat](https://hardhat.org/) e [Truffle](https://archive.trufflesuite.com/), usando [crytic-compile](https://github.com/crytic/crytic-compile). Para invocar o Echidna com o framework de compilação atual, use `echidna .`.
Além disso, o Echidna suporta dois modos de teste de contratos complexos. Primeiramente, pode-se [aproveitar o estado de rede existente](https://secure-contracts.com/program-analysis/echidna/advanced/state-network-forking.html) e usá-lo como estado base para o Echidna. Em segundo lugar, o Echidna pode chamar qualquer contrato com uma ABI conhecida passando o código-fonte Solidity correspondente na CLI. Use `allContracts: true` na sua configuração para ativar isso.
### Curso intensivo sobre o Echidna
Nosso repositório [Building Secure Smart Contracts](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial) contém um curso intensivo sobre o Echidna, incluindo exemplos, lições e exercícios.
### Usando o Echidna em um workflow do GitHub Actions
Existe uma action do Echidna que pode ser usada para executar o `echidna` como parte de um
workflow do GitHub Actions. Consulte o repositório
[crytic/echidna-action](https://github.com/crytic/echidna-action) para
instruções de uso e exemplos.
### Opções de configuração
A CLI do Echidna pode ser usada para escolher o contrato a testar e carregar um
arquivo de configuração.```sh
$ echidna contract.sol --contract TEST --config config.yaml
```
O arquivo de configuração permite que os usuários escolham parâmetros de EVM e de geração de testes. Um exemplo de arquivo de configuração completo e anotado com as opções padrão pode ser encontrado em
[tests/solidity/basic/default.yaml](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/default.yaml).
Consulte a [documentação](https://secure-contracts.com/program-analysis/echidna/configuration.html)
para informações mais detalhadas sobre as opções de configuração disponíveis.
O Echidna suporta três drivers de saída diferentes. Há o driver padrão `text`,
um driver `json` e um driver `none`, que deve suprimir toda
a saída de `stdout`. O driver JSON reporta a campanha geral da seguinte forma.```
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` é um dict que descreve certas chamadas que aumentam a cobertura. Essas interfaces estão sujeitas a alterações para se tornarem um pouco mais amigáveis ao usuário em uma data posterior. `testType` será um dos seguintes: `property`, `assertion`, `optimization`, `exploration` ou `call`, e `status` sempre assume um dos valores `fuzzing`, `shrinking`, `solved`, `passed` ou `error`.
### Depurando Problemas de Desempenho
Uma maneira de diagnosticar problemas de desempenho do Echidna é executar o `echidna` com profiling ativado.
Para executar o Echidna com profiling básico, adicione `+RTS -p -s` ao seu comando `echidna` original:```sh
$ nix develop # alternatively nix-shell
$ cabal --enable-profiling run echidna -- ... +RTS -p -s
$ less echidna.prof
```
Isso produz um arquivo de relatório (`echidna.prof`), que mostra quais funções consomem mais CPU e memória.
Se a criação de perfil básica não ajudar, você pode usar [técnicas de criação de perfil mais avançadas](https://haskell.foundation/hs-opt-handbook.github.io/src/Measurement_Observation/Haskell_Profiling/eventlog.html).
Causas comuns de problemas de desempenho que observamos:
- Funções custosas chamadas em caminhos críticos
- Construtores de dados preguiçosos que acumulam thunks
- Estruturas de dados ineficientes usadas em caminhos críticos
Verificar esses pontos é um bom lugar para começar. Se você suspeitar que alguma computação é preguiçosa demais e
vaza memória, você pode usar `force` de `Control.DeepSeq` para garantir que ela seja avaliada.
## Limitações e problemas conhecidos
A emulação e o teste de EVM são difíceis. O Echidna tem algumas limitações na versão mais recente. Algumas delas
são herdadas do [hevm](https://github.com/argotorg/hevm), enquanto outras são resultados de
decisões de design/desempenho ou simplesmente bugs no nosso código. Nós as listamos aqui, incluindo suas
issues correspondentes e o status ("wont fix", "on hold", "in review", "fixed"). As issues que estão
"fixed" devem ser incluídas na próxima versão do Echidna.
| Descrição | Issue | Status |
| :--- | :---: | :---: |
| O suporte ao Vyper é limitado | [#652](https://github.com/crytic/echidna/issues/652) | *wont fix* |
| Suporte limitado a bibliotecas para testes | [#651](https://github.com/crytic/echidna/issues/651) | *wont fix* |
## Instalação
### Binários pré-compilados
Antes de começar, certifique-se de que o Slither está [instalado](https://github.com/crytic/slither) (`pip3 install slither-analyzer --user`).
Se você quiser testar o Echidna rapidamente no Linux ou MacOS, nós fornecemos binários Linux estaticamente vinculados, compilados no Ubuntu, e binários MacOS majoritariamente estáticos na nossa [página de releases](https://github.com/crytic/echidna/releases). Você também pode obter o mesmo tipo de binários do nosso [pipeline de CI](https://github.com/crytic/echidna/actions?query=workflow%3ACI+branch%3Amaster+event%3Apush); basta clicar no commit para encontrar binários para Linux ou MacOS.
### Homebrew (macOS / Linux)
Se você tem o Homebrew instalado na sua máquina Mac ou Linux, você pode instalar o Echidna e todas as suas dependências (Slither, crytic-compile) executando `brew install echidna`.
Você também pode compilar e instalar o código mais recente do branch `master` executando `brew install --HEAD echidna`
Você pode obter mais informações na página da [Fórmula Homebrew do `echidna`](https://formulae.brew.sh/formula/echidna). A fórmula em si é mantida como parte do [repositório homebrew-core](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/echidna.rb)
### Contêiner Docker
Se você preferir usar um contêiner Docker pré-construído, confira nosso [pacote
docker](https://github.com/orgs/crytic/packages?repo_name=echidna), que é
construído automaticamente via GitHub Actions. O contêiner `echidna` é baseado em
`ubuntu:noble` e tem como objetivo ser uma imagem pequena, mas flexível o suficiente, para usar
o Echidna. Ele fornece uma versão pré-construída do `echidna`, bem como
`slither`, `crytic-compile`, `solc-select`, `nvm` e `foundry` (incluindo
`forge`, `cast`, `anvil` e `chisel`) em menos de 200 MB.
Observe que as imagens de contêiner atualmente só são construídas em sistemas x86. Executá-las
em dispositivos ARM, como sistemas Mac M1, não é recomendado devido à perda de desempenho
causada pela emulação de CPU.
Diferentes tags estão disponíveis para a imagem do contêiner Docker:
| Tag | Build in tag
|---------------|-------------
| `vx.y.z` | Build correspondente à release `vx.y.z`
| `latest` | Última release marcada do Echidna.
| `edge` | Commit mais recente no branch padrão.
| `testing-foo` | Build de teste baseado no branch `foo`.
Para executar o contêiner com a versão mais recente do Echidna de forma interativa, você pode usar
algo como o seguinte comando. Ele mapeará o diretório atual como
`/src` dentro do contêiner e fornecerá um shell onde você pode usar
`echidna`:```sh
$ docker run --rm -it -v "$(pwd)":/src ghcr.io/crytic/echidna/echidna
```
Caso contrário, se você quiser compilar localmente a versão mais recente do Echidna, recomendamos usar Docker. Dentro de um clone deste repositório, execute o seguinte comando para compilar a imagem do contêiner Docker:```sh
$ docker build -t echidna -f docker/Dockerfile --target final-ubuntu .
```
Em seguida, você pode executar a imagem `echidna` localmente. Por exemplo, para instalar o solc
0.5.7 e verificar `tests/solidity/basic/flags.sol`, você pode executar:```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"
```
A imagem Docker também inclui as ferramentas Foundry para desenvolvimento e testes abrangentes de contratos inteligentes. Você pode usar `forge`, `cast`, `anvil` e `chisel` diretamente no contêiner:```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
```
### Compilando usando Stack
Se você preferir compilar a partir do código-fonte, use [Stack](https://docs.haskellstack.org/en/stable/). `stack install` deve compilar e construir o `echidna` em `~/.local/bin`. Você precisará fazer link com libreadline e libsecp256k1 (compilada com recovery habilitado), que devem ser instaladas com o gerenciador de pacotes de sua escolha. Você também precisa instalar a versão mais recente do [libff](https://github.com/scipr-lab/libff). Consulte nossos [testes de CI](https://github.com/crytic/echidna/blob/master/.github/scripts/install-libff.sh) para orientação.
Algumas distribuições Linux não fornecem bibliotecas estáticas para certas coisas que o Haskell precisa, por exemplo, Arch Linux, o que fará com que `stack build` falhe com erros de linking porque usamos a flag `-static`. Nesse caso, use `--flag echidna:-static` para produzir um binário com link dinâmico.
Se você estiver recebendo erros de compilação relacionados a linking, tente mexer com `--extra-include-dirs` e `--extra-lib-dirs`.
### Compilando usando Nix (funciona nativamente em sistemas Apple M1)
[Usuários do Nix](https://nixos.org/download/) podem instalar o Echidna mais recente com:```sh
$ nix-env -i -f https://github.com/crytic/echidna/tarball/master
```
Com flakes habilitados, você pode executar o Echidna diretamente deste repositório:```sh
$ nix run github:crytic/echidna # master
$ nix run github:crytic/echidna/v2.1.1 # specific ref (tag/branch/commit)
```
Para compilar uma versão autónoma para sistemas macOS sem Nix, o seguinte irá
compilar o Echidna num binário maioritariamente estático. Isto também pode ser usado em sistemas Linux
para produzir um binário totalmente estático.```sh
$ nix build .#echidna-redistributable
```
O Nix instalará automaticamente todas as dependências necessárias para o desenvolvimento, incluindo `crytic-compile` e `solc`. Uma forma rápida de começar a desenvolver o 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
```
### Executando as suítes de teste
`cabal run tests` é a suíte Haskell, e cobre tudo o que o Echidna faz em
processo.
O servidor MCP é testado fora do processo, iniciando uma campanha real e
conduzindo-a da forma como um cliente agente faria. Essa suíte é em Python, e precisa de um
`echidna` no `$PATH`:```sh
$ pip install -r tests/mcp/requirements-test.txt
$ pytest tests/mcp -v
```
Aponte-o para uma campanha que você mesmo iniciou com `ECHIDNA_MCP_URL`, para uma porta diferente com `ECHIDNA_MCP_PORT`, ou para um binário específico com `ECHIDNA_BIN`. Um exemplo de um agente conduzindo uma campanha através da mesma interface está em [examples/](https://github.com/crytic/echidna/blob/master/examples/README.md).
## Uso público do Echidna
### Suítes de testes de propriedades
Esta é uma lista parcial de projetos de contratos inteligentes que usam o Echidna para testes:
* [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)
### Revisões de segurança
A seguir estão revisões de segurança públicas que usaram o Echidna para descobrir vulnerabilidades
- [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)
### Troféus
As seguintes vulnerabilidades de segurança foram encontradas pelo Echidna. Se você encontrou uma vulnerabilidade de segurança usando nossa ferramenta, por favor envie um PR com as informações relevantes.
| Projeto | Vulnerabilidade | Data |
|--|--|--|
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Se uma ordem não pode ser preenchida, então ela não pode ser cancelada | Out 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Se uma ordem pode ser parcialmente preenchida com zero, então ela pode ser parcialmente preenchida com um token | Out 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | A função cobbdouglas não reverte quando parâmetros de entrada válidos são usados | Out 2019
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Um atacante não pode roubar ativos de um pool público | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Um atacante não pode gerar tokens de pool gratuitos com joinPool | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Chamar joinPool-exitPool não leva a tokens de pool gratuitos | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Chamar exitswapExternAmountOut não leva a ativos gratuitos | Jan 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Fechar troves exige manter o valor total de LUSD cunhado](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dez 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Troves podem ser removidos incorretamente](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dez 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | O resgate inicial pode reverter inesperadamente | Dez 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Resgatar sem resgates ainda pode retornar sucesso | Dez 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Usuários podem transferir mais tokens do que possuem | Nov 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Saldos de usuários podem ser maiores que o suprimento total | Nov 2020
[Yield Protocol](https://github.com/trailofbits/publications/blob/master/reviews/YieldProtocol.pdf) | O cálculo aritmético para comprar e vender tokens é impreciso | Ago 2020
### Pesquisa
Também podemos usar o Echidna para reproduzir exemplos de pesquisa de artigos sobre fuzzing de contratos inteligentes para mostrar quão rapidamente ele pode encontrar a solução. Todos esses podem ser resolvidos, em alguns segundos a um ou dois minutos em um laptop.
| Fonte | Código
|--|--
[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)
### Publicações Acadêmicas
| Título do Artigo | Evento | Data de Publicação |
| --- | --- | --- |
| [echidna-parade: Diverse multicore smart contract fuzzing](https://agroce.github.io/issta21.pdf) | [ISSTA 2021](https://conf.researchr.org/home/issta-2021) | Julho 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) | Julho 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) | Fev 2020 |
Se você está usando o Echidna para trabalho acadêmico, considere se candidatar ao [Crytic $10k Research Prize](https://blog.trailofbits.com/2019/11/13/announcing-the-crytic-10k-research-prize/).
## Obtendo ajuda
Sinta-se à vontade para passar pelo nosso canal slack #ethereum em [Empire Hacking](https://slack.empirehacking.nyc/) para obter ajuda sobre como usar ou estender o Echidna.
* Comece revisando estas simples [Echidna invariants](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol)
* Considere [enviar um e-mail](mailto:[email protected]) diretamente para a equipe de desenvolvimento do Echidna para perguntas mais detalhadas
## Licença
O Echidna é licenciado e distribuído sob a [licença AGPLv3](https://github.com/crytic/echidna/blob/master/LICENSE).