Volver a actualizaciones
Nuevo releaseJul 27, 2026

echidna v2.3.3

Fuzzer de contratos inteligentes de Ethereum

Compartir

Echidna: Un Fuzzer Rápido para Smart Contracts

Build Status

Echidna es una criatura extraña que come insectos y es altamente electrosensible (con disculpas a Jacob Stanley)

Más en serio, Echidna es un programa en Haskell diseñado para fuzzing/pruebas basadas en propiedades de smart contracts de Ethereum. Utiliza sofisticadas campañas de fuzzing basadas en gramática, basadas en un ABI de contrato para falsificar predicados definidos por el usuario o afirmaciones de Solidity. Diseñamos Echidna teniendo en cuenta la modularidad, por lo que se puede extender fácilmente para incluir nuevas mutaciones o probar contratos específicos en casos específicos.

Características

  • Genera entradas adaptadas a tu código real
  • Recopilación opcional de corpus, mutación y guía de cobertura para encontrar errores más profundos
  • Impulsado por Slither para extraer información útil antes de la campaña de fuzzing
  • Integración con el código fuente para identificar qué líneas están cubiertas después de la campaña de fuzzing
  • Interfaz de terminal interactiva, salida solo texto o JSON
  • Minimización automática de casos de prueba para una clasificación rápida
  • Integración perfecta en el flujo de trabajo de desarrollo

.. y un hermoso logotipo artesanal de alta resolución.

Uso

Ejecución del ejecutor de pruebas

La funcionalidad principal de Echidna es un ejecutable llamado echidna, que toma como entrada un contrato y una lista de invariantes (propiedades que siempre deben cumplirse). Para cada invariante, genera secuencias aleatorias de llamadas al contrato y verifica si el invariante se cumple. Si encuentra alguna forma de falsificar el invariante, imprime la secuencia de llamadas que lo logra. Si no puede, tienes cierta seguridad de que el contrato es seguro.

Escritura de invariantes

Los invariantes se expresan como funciones de Solidity con nombres que comienzan con echidna_, no tienen argumentos y devuelven un booleano. Por ejemplo, si tienes alguna variable balance que nunca debe bajar de 20, puedes escribir una función adicional en tu contrato como esta:```solidity function echidna_check_balance() public returns (bool) { return(balance >= 20); }

Para comprobar estos invariantes, ejecuta:```sh
$ echidna myContract.sol

Se puede encontrar un contrato de ejemplo con pruebas en tests/solidity/basic/flags.sol. Para ejecutarlo, debe ejecutar:```sh $ echidna tests/solidity/basic/flags.sol

Echidna debería encontrar una secuencia de llamadas que falsifique `echidna_sometimesfalse` y debería ser incapaz de encontrar una entrada falsificadora para `echidna_alwaystrue`.

### Modos de prueba

El ejemplo anterior usa el modo **property** predeterminado, pero Echidna admite varios modos de prueba, configurados mediante `testMode` en el archivo de configuración o `--test-mode` en la CLI:

* **`property`** (predeterminado): Prueba funciones con prefijo `echidna_` que devuelven `bool`.
* **`assertion`**: Detecta fallos de aserción de `assert()` y los ayudantes `assertX` de Foundry (`assertTrue`, `assertEq`, etc.).
* **`foundry`**: Ejecuta pruebas unitarias estilo Foundry con prefijo `test` e invariantes de estado con prefijo `invariant_`.
* **`overflow`**: Detecta desbordamientos de enteros (Solidity >= 0.8.0).
* **`optimization`**: Maximiza el valor de retorno de funciones con prefijo `echidna_` que devuelven `int256` (usa el mismo prefijo configurable que el modo property).
* **`exploration`**: Recolecta cobertura sin verificar propiedades.

### Recolectando y visualizando cobertura

Después de finalizar una campaña, Echidna puede guardar un **corpus** que maximiza la cobertura en un directorio especial especificado con la opción de configuración `corpusDir`. Este directorio contendrá dos entradas: (1) un directorio llamado `coverage` con archivos JSON que pueden ser reproducidos por Echidna y (2) un archivo de texto plano llamado `covered.txt`, una copia del código fuente con anotaciones de cobertura.

Si ejecutas el ejemplo `tests/solidity/basic/flags.sol`, Echidna guardará algunos archivos con transacciones serializadas en el directorio `coverage` y un archivo `covered.$(date +%s).txt` con las siguientes líneas:```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;
  }

Nuestra herramienta señala cada traza de ejecución en el corpus con el siguiente "marcador de línea":

  • * si una ejecución terminó con un STOP
  • r si una ejecución terminó con un REVERT
  • o si una ejecución terminó con un error de falta de gas
  • e si una ejecución terminó con cualquier otro error (división por cero, fallo de aserción, etc.)

Soporte para sistemas de compilación de contratos inteligentes

Echidna puede probar contratos compilados con diferentes sistemas de compilación de contratos inteligentes, incluyendo Foundry, Hardhat, y Truffle, utilizando crytic-compile. Para invocar Echidna con el marco de compilación actual, use echidna ..

Además, Echidna admite dos modos de probar contratos complejos. En primer lugar, se puede aprovechar el estado de red existente y usarlo como estado base para Echidna. En segundo lugar, Echidna puede llamar a cualquier contrato con un ABI conocido pasando el código fuente de Solidity correspondiente en la CLI. Use allContracts: true en su configuración para activar esto.

Curso intensivo sobre Echidna

Nuestro repositorio Building Secure Smart Contracts contiene un curso intensivo sobre Echidna, que incluye ejemplos, lecciones y ejercicios.

Usando Echidna en un flujo de trabajo de GitHub Actions

Hay una acción de Echidna que se puede usar para ejecutar echidna como parte de un flujo de trabajo de GitHub Actions. Consulte el repositorio crytic/echidna-action para obtener instrucciones de uso y ejemplos.

Opciones de configuración

La CLI de Echidna se puede usar para elegir el contrato a probar y cargar un archivo de configuración.```sh $ echidna contract.sol --contract TEST --config config.yaml

El archivo de configuración permite a los usuarios elegir la EVM y los parámetros de generación
de pruebas. Un ejemplo de un archivo de configuración completo y anotado con las opciones
predeterminadas se puede encontrar en
[tests/solidity/basic/default.yaml](https://github.com/crytic/echidna/blob/HEAD/tests/solidity/basic/default.yaml).
Consulte la [documentación](https://secure-contracts.com/program-analysis/echidna/configuration.html)
para obtener información más detallada sobre las opciones de configuración disponibles.

Echidna admite tres controladores de salida diferentes. Existe el controlador `text`
predeterminado, un controlador `json` y un controlador `none`, que debe suprimir toda la
salida `stdout`. El controlador JSON informa la campaña general de la siguiente manera.```
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 es un dict que describe ciertas llamadas que aumentan la cobertura. Estas interfaces están sujetas a cambios para ser un poco más fáciles de usar en una fecha posterior. testType será uno de property, assertion, optimization, exploration, o call, y status siempre toma uno de fuzzing, shrinking, solved, passed, o error.

Depuración de Problemas de Rendimiento

Una forma de diagnosticar los problemas de rendimiento de Echidna es ejecutar echidna con la creación de perfiles activada. Para ejecutar Echidna con creación de perfiles básica, agregue +RTS -p -s a su comando echidna original:```sh $ nix develop # alternatively nix-shell $ cabal --enable-profiling run echidna -- ... +RTS -p -s $ less echidna.prof

Esto produce un archivo de informe (`echidna.prof`), que muestra qué funciones consumen más CPU y memoria.

Si la creación de perfiles básica no ayuda, puedes usar [técnicas avanzadas de creación de perfiles](https://haskell.foundation/hs-opt-handbook.github.io/src/Measurement_Observation/Haskell_Profiling/eventlog.html).

Causas comunes de problemas de rendimiento que hemos observado:

- Funciones costosas llamadas en rutas críticas
- Constructores de datos perezosos que acumulan thunks
- Estructuras de datos ineficientes utilizadas en rutas críticas

Verificar estos puntos es un buen punto de partida. Si sospechas que algún cálculo es demasiado perezoso y tiene fugas de memoria, puedes usar `force` de `Control.DeepSeq` para asegurarte de que se evalúe.

## Limitaciones y problemas conocidos

La emulación y las pruebas de EVM son difíciles. Echidna tiene algunas limitaciones en la última versión. Algunas de ellas son heredadas de [hevm](https://github.com/argotorg/hevm) mientras que otras son resultado de decisiones de diseño/rendimiento o simplemente errores en nuestro código. Las enumeramos aquí incluyendo su problema correspondiente y el estado ("wont fix", "on hold", "in review", "fixed"). Los problemas que están "fixed" se espera que se incluyan en la próxima versión de Echidna.

| Descripción | Problema | Estado |
| :---        | :---: | :---:  |
| El soporte de Vyper es limitado | [#652](https://github.com/crytic/echidna/issues/652) | *wont fix* |
| Soporte limitado de bibliotecas para pruebas | [#651](https://github.com/crytic/echidna/issues/651) | *wont fix* |

## Instalación

### Binarios precompilados

Antes de comenzar, asegúrate de que Slither esté [instalado](https://github.com/crytic/slither) (`pip3 install slither-analyzer --user`). Si deseas probar Echidna rápidamente en Linux o MacOS, proporcionamos binarios de Linux enlazados estáticamente compilados en Ubuntu y binarios de MacOS en su mayoría estáticos en nuestra [página de lanzamientos](https://github.com/crytic/echidna/releases). También puedes obtener el mismo tipo de binarios desde nuestro [pipeline de CI](https://github.com/crytic/echidna/actions?query=workflow%3ACI+branch%3Amaster+event%3Apush), simplemente haz clic en el commit para encontrar binarios para Linux o MacOS.

### Homebrew (macOS / Linux)

Si tienes Homebrew instalado en tu Mac o máquina Linux, puedes instalar Echidna y todas sus dependencias (Slither, crytic-compile) ejecutando `brew install echidna`.

También puedes compilar e instalar el código de la rama `master` más reciente ejecutando `brew install --HEAD echidna`

Puedes obtener más información en la página de la [`echidna` Homebrew Formula](https://formulae.brew.sh/formula/echidna). La fórmula en sí se mantiene como parte del [repositorio homebrew-core](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/echidna.rb)

### Contenedor Docker

Si prefieres usar un contenedor Docker preconstruido, consulta nuestro [paquete docker](https://github.com/orgs/crytic/packages?repo_name=echidna), que se construye automáticamente mediante GitHub Actions. El contenedor `echidna` está basado en `ubuntu:noble` y está diseñado para ser una imagen pequeña pero suficientemente flexible para usar Echidna. Proporciona una versión preconstruida de `echidna`, así como `slither`, `crytic-compile`, `solc-select`, `nvm`, y `foundry` (incluyendo `forge`, `cast`, `anvil`, y `chisel`) en menos de 200 MB.

Ten en cuenta que las imágenes del contenedor actualmente solo se compilan en sistemas x86. No se recomienda ejecutarlas en dispositivos ARM, como sistemas Mac M1, debido a la pérdida de rendimiento causada por la emulación de la CPU.

Hay diferentes etiquetas disponibles para la imagen del contenedor Docker:

| Etiqueta       | Compilación en etiqueta |
|---------------|-------------|
| `vx.y.z`      | Compilación correspondiente al lanzamiento `vx.y.z` |
| `latest`      | Último lanzamiento etiquetado de Echidna. |
| `edge`        | Commit más reciente en la rama por defecto. |
| `testing-foo` | Compilación de prueba basada en la rama `foo`. |

Para ejecutar el contenedor con la última versión de Echidna de forma interactiva, puedes usar algo como el siguiente comando. Mapeará el directorio actual como `/src` dentro del contenedor, y te dará un shell donde puedes usar `echidna`:```sh
$ docker run --rm -it -v "$(pwd)":/src ghcr.io/crytic/echidna/echidna

De lo contrario, si quieres construir localmente la última versión de Echidna, recomendamos usar Docker. Desde un clon de este repositorio, ejecuta el siguiente comando para construir la imagen del contenedor Docker:```sh $ docker build -t echidna -f docker/Dockerfile --target final-ubuntu .

Luego, puedes ejecutar la imagen `echidna` localmente. Por ejemplo, para instalar solc 0.5.7 y verificar `tests/solidity/basic/flags.sol`, puedes ejecutar:```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"

La imagen de Docker también incluye las herramientas de Foundry para el desarrollo y prueba integral de contratos inteligentes. Puedes usar forge, cast, anvil y chisel directamente en el contenedor:```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

### Building usando Stack

Si prefieres compilar desde el código fuente, usa [Stack](https://docs.haskellstack.org/en/stable/). `stack install` debería compilar y construir `echidna` en `~/.local/bin`. Necesitarás enlazar contra libreadline y libsecp256k1 (compilado con recovery habilitado), las cuales deberían instalarse con el gestor de paquetes de tu elección. También necesitas instalar la última versión de [libff](https://github.com/scipr-lab/libff). Consulta nuestras [pruebas CI](https://github.com/crytic/echidna/blob/HEAD/.github/scripts/install-libff.sh) para obtener orientación.

Algunas distribuciones de Linux no incluyen bibliotecas estáticas para ciertos elementos que Haskell necesita, por ejemplo Arch Linux, lo que provocará que `stack build` falle con errores de enlace porque usamos la bandera `-static`. En ese caso, usa `--flag echidna:-static` para producir un binario enlazado dinámicamente.

Si tienes errores de compilación relacionados con el enlace, prueba a ajustar `--extra-include-dirs` y `--extra-lib-dirs`.

### Building usando Nix (funciona de forma nativa en sistemas Apple M1)

[Los usuarios de Nix](https://nixos.org/download/) pueden instalar la última versión de Echidna con:```sh
$ nix-env -i -f https://github.com/crytic/echidna/tarball/master

Con flakes habilitados, puedes ejecutar Echidna directamente desde este repositorio:```sh $ nix run github:crytic/echidna # master $ nix run github:crytic/echidna/v2.1.1 # specific ref (tag/branch/commit)

Para compilar una versión independiente para sistemas macOS que no sean Nix, lo siguiente compilará Echidna en un binario mayormente estático. Esto también se puede usar en sistemas Linux para producir un binario completamente estático.```sh
$ nix build .#echidna-redistributable

Nix instalará automáticamente todas las dependencias necesarias para el desarrollo, incluyendo crytic-compile y solc. Una forma rápida de empezar a desarrollar 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 de Echidna

### Suites de pruebas de propiedades

Esta es una lista parcial de proyectos de contratos inteligentes que usan Echidna para pruebas:

* [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)

### Revisiones de seguridad

A continuación se muestran revisiones de seguridad públicas que utilizaron Echidna para descubrir 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)

### Trofeos

Las siguientes vulnerabilidades de seguridad fueron encontradas por Echidna. Si encontraste una vulnerabilidad de seguridad usando nuestra herramienta, por favor envía un PR con la información relevante.

| Proyecto | Vulnerabilidad | Fecha |
|--|--|--|
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Si una orden no puede ser completada, entonces no puede ser cancelada | Oct 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | Si una orden puede ser completada parcialmente con cero, entonces puede ser completada parcialmente con un token | Oct 2019
[0x Protocol](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) | La función cobbdouglas no revierte cuando se usan parámetros de entrada válidos | Oct 2019
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Un atacante no puede robar activos de un pool público | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Un atacante no puede generar tokens de pool gratuitos con joinPool | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Llamar a joinPool-exitPool no lleva a obtener tokens de pool gratuitos | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Llamar a exitswapExternAmountOut no lleva a obtener activos gratuitos | Jan 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Cerrar troves requiere tener la cantidad completa de LUSD acuñado](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dec 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Los troves pueden ser eliminados incorrectamente](https://github.com/liquity/dev/blob/echidna_ToB_final/packages/contracts/contracts/TestContracts/E2E.sol#L242-L298) | Dec 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | El redeem inicial puede revertir inesperadamente | Dec 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | Redeem sin redenciones podría aún devolver éxito | Dec 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Se permite a los usuarios transferir más tokens de los que tienen | Nov 2020
[Origin Dollar](https://github.com/trailofbits/publications/blob/master/reviews/OriginDollar.pdf) | Los saldos de los usuarios pueden ser mayores que el suministro total | Nov 2020
[Yield Protocol](https://github.com/trailofbits/publications/blob/master/reviews/YieldProtocol.pdf) | El cálculo aritmético para comprar y vender tokens es impreciso | Aug 2020

### Investigación

También podemos usar Echidna para reproducir ejemplos de investigación de artículos sobre fuzzing de contratos inteligentes, mostrando qué tan rápido puede encontrar la solución. Todos estos pueden resolverse, desde unos segundos hasta uno o dos minutos en una computadora portátil.

| Fuente | 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)

### Publicaciones académicas

| Título del artículo | Lugar de publicación | Fecha de publicación |
| --- | --- | --- |
| [echidna-parade: Diverse multicore smart contract fuzzing](https://agroce.github.io/issta21.pdf) | [ISSTA 2021](https://conf.researchr.org/home/issta-2021) | July 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) | July 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 |

Si estás usando Echidna para trabajos académicos, considera postularte al [Premio de Investigación Crytic de $10k](https://blog.trailofbits.com/2019/11/13/announcing-the-crytic-10k-research-prize/).

## Obteniendo ayuda

No dudes en visitar nuestro canal de Slack #ethereum en [Empire Hacking](https://slack.empirehacking.nyc/) para obtener ayuda sobre cómo usar o extender Echidna.

* Comienza revisando estos simples [invariantes de Echidna](https://github.com/crytic/echidna/blob/HEAD/tests/solidity/basic/flags.sol)

* Considera [enviar un correo electrónico](mailto:[email protected]) directamente al equipo de desarrollo de Echidna para preguntas más detalladas

## Licencia

Echidna está licenciado y distribuido bajo la [licencia AGPLv3](https://github.com/crytic/echidna/blob/master/LICENSE).
Leer más

Categorías

Análisis de VulnerabilidadesFuzzing