crytic/echidnaFuzzer de contratos inteligentes Ethereum
Echidna é uma criatura estranha que come bugs e é altamente eletrossensível (com pedidos de desculpas a Jacob Stanley)
Mais seriamente, Echidna é um programa Haskell projetado para fuzzing/testes baseados em propriedades de smart contracts Ethereum. Ele usa campanhas sofisticadas de fuzzing baseadas em gramática, orientadas pela ABI do contrato, para falsificar predicados definidos pelo usuário ou asserções do Solidity. 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.
.. e um belo logotipo artesanal de alta resolução.
A funcionalidade principal 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 maneira
de falsificar a invariante, ele imprime a sequência de chamadas que faz isso. Se não conseguir, você tem alguma
garantia de que o contrato é seguro.
Invariantes são expressas como funções Solidity com nomes que começam com echidna_, sem argumentos, e que 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. Para executá-lo, você deve executar:```sh $ echidna tests/solidity/basic/flags.sol
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** (propriedade) 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 ajudantes `assertX` do Foundry (`assertTrue`, `assertEq`, etc.).
* **`foundry`**: Executa testes unitários com prefixo `test` no estilo Foundry e invariantes stateful com prefixo `invariant_`.
* **`overflow`**: Detecta estouros de inteiros (over/underflows) (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 que o 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 rastro de execução no corpus com o seguinte "marcador de linha":
* se uma execução terminou com STOPr se uma execução terminou com REVERTo se uma execução terminou com erro de falta de gáse se uma execução terminou com qualquer outro erro (divisão por zero, falha de asserção, etc)Echidna pode testar contratos compilados com diferentes sistemas de construção de contratos inteligentes, incluindo Foundry, Hardhat, e Truffle, usando crytic-compile. Para invocar o Echidna com o framework de compilação atual, use echidna ..
Além disso, o Echidna suporta dois modos de testar contratos complexos. Primeiramente, pode-se aproveitar o estado de rede existente e usar isso 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.
Nosso repositório Building Secure Smart Contracts contém um curso intensivo sobre Echidna, incluindo exemplos, lições e exercícios.
Existe uma ação do Echidna que pode ser usada para executar echidna como parte de um fluxo de trabalho do GitHub Actions. Consulte o repositório crytic/echidna-action para instruções de uso e exemplos.
A CLI do Echidna pode ser usada para escolher o contrato a ser testado 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 um 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/HEAD/tests/solidity/basic/default.yaml).
Consulte a [documentação](https://secure-contracts.com/program-analysis/echidna/configuration.html)
para obter informações mais detalhadas sobre as opções de configuração disponíveis.
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 `stdout`. O driver JSON relata 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 dicionário 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 futura. testType será um de property, assertion, optimization, exploration ou call, e status sempre assume um dos valores: fuzzing, shrinking, solved, passed ou error.
Uma maneira de diagnosticar problemas de desempenho do Echidna é executar echidna com a criação de perfil ativada. Para executar o Echidna com criação de perfil básica, 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 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 itens é um bom ponto de partida. Se você suspeitar que alguma computação é muito preguiçosa e vaza memória, pode usar `force` de `Control.DeepSeq` para garantir que seja avaliada.
## Limitações e problemas conhecidos
A emulação e teste de EVM são difíceis. Echidna tem algumas limitações na última versão. 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 em nosso código. Listamo-las aqui incluindo seu issue correspondente e o status ("wont fix", "on hold", "in review", "fixed"). As issues que estão "fixed" são esperadas para serem incluídas na próxima versão do Echidna.
| Description | Issue | Status |
| :--- | :---: | :---: |
| O suporte a Vyper é limitado | [#652](https://github.com/crytic/echidna/issues/652) | *wont fix* |
| Suporte limitado a bibliotecas para teste | [#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 quiser testar rapidamente o Echidna no Linux ou MacOS, fornecemos binários do Linux estaticamente ligados construídos no Ubuntu e binários do MacOS principalmente estáticos em 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ê tiver o Homebrew instalado no seu Mac ou Linux, 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 da branch `master` mais recente executando `brew install --HEAD echidna`
Você pode obter mais informações na página [`echidna` Homebrew Formula](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 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 no `ubuntu:noble` e é destinado a ser uma imagem pequena mas suficientemente flexível 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`) com menos de 200 MB.
Note que as imagens do contêiner atualmente são construídas apenas em sistemas x86. A execução em dispositivos ARM, como sistemas Mac M1, não é recomendada 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` | Release mais recente com tag do Echidna.
| `edge` | Commit mais recente na branch padrão.
| `testing-foo` | Build de teste baseado na branch `foo`.
Para executar o contêiner com a versão mais recente do Echidna interativamente, 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 o Docker. A partir de um clone deste repositório, execute o seguinte comando para construir a imagem do container Docker:```sh $ docker build -t echidna -f docker/Dockerfile --target final-ubuntu .
Então, pode executar a imagem `echidna` localmente. Por exemplo, para instalar o solc
0.5.7 e verificar `tests/solidity/basic/flags.sol`, 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 ferramentas Foundry para desenvolvimento e teste abrangentes de contratos inteligentes. Você pode usar forge, cast, anvil e chisel diretamente no container:```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
### Construção usando Stack
Se preferir compilar a partir do código-fonte, use [Stack](https://docs.haskellstack.org/en/stable/). `stack install` deve construir e compilar `echidna` em `~/.local/bin`. Você precisará vincular com libreadline e libsecp256k1 (construídas com recuperação ativada), que devem ser instaladas com o gerenciador de pacotes de sua escolha. Você também precisa instalar a versão mais recente de [libff](https://github.com/scipr-lab/libff). Consulte nossos [testes de CI](https://github.com/crytic/echidna/blob/HEAD/.github/scripts/install-libff.sh) para orientação.
Algumas distribuições Linux não fornecem bibliotecas estáticas para certas coisas que Haskell precisa, por exemplo, Arch Linux, o que fará com que `stack build` falhe com erros de vinculação porque usamos a flag `-static`. Nesse caso, use `--flag echidna:-static` para produzir um binário vinculado dinamicamente.
Se você estiver obtendo erros de compilação relacionados à vinculação, tente ajustar `--extra-include-dirs` e `--extra-lib-dirs`.
### Construção 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 ativados, 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 construir uma versão independente para sistemas macOS não-Nix, o seguinte construirá o Echidna em um binário majoritariamente estático. Isso também pode ser usado em sistemas Linux para produzir um binário completamente estático.```sh
$ nix build .#echidna-redistributable
Nix instalará automaticamente todas as dependências necessárias para o desenvolvimento, incluindo crytic-compile e solc. Uma maneira rápida de começar a desenvolver 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 público do Echidna
### Suítes de teste de propriedades
Esta é uma lista parcial de projetos de contratos inteligentes que usam 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, são apresentadas revisões de segurança públicas que usaram 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, 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 requer 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 indevidamente](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) | Resgate 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 fornecimento 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 Echidna para reproduzir exemplos de pesquisa de artigos sobre fuzzing de contratos inteligentes para mostrar com que rapidez ele encontra a solução. Todos estes 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 | Local | 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) | Fevereiro 2020 |
Se você está usando Echidna para trabalho acadêmico, considere se candidatar ao [Prêmio de Pesquisa Crytic $10k](https://blog.trailofbits.com/2019/11/13/announcing-the-crytic-10k-research-prize/).
## Obtendo ajuda
Sinta-se à vontade para passar em nosso canal #ethereum slack no [Empire Hacking](https://slack.empirehacking.nyc/) para obter ajuda ao usar ou estender o Echidna.
* Comece revisando estes simples [invariantes do Echidna](https://github.com/crytic/echidna/blob/HEAD/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).