crytic/echidnaFuzzer de contratos inteligentes de Ethereum
# Echidna: Un 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 es una criatura extraña que se alimenta de bugs y es altamente electrosensible (con disculpas a Jacob Stanley)
Hablando más en serio, Echidna es un programa en Haskell diseñado para el fuzzing/pruebas basadas en propiedades de contratos inteligentes de Ethereum. Utiliza sofisticadas campañas de fuzzing basadas en gramáticas a partir de un [ABI de contrato](https://docs.soliditylang.org/en/develop/abi-spec.html) para falsificar predicados definidos por el usuario o [aserciones de Solidity](https://docs.soliditylang.org/en/develop/control-structures.html#error-handling-assert-require-revert-and-exceptions). Diseñamos Echidna pensando en la modularidad, por lo que puede extenderse fácilmente para incluir nuevas mutaciones o probar contratos específicos en casos concretos.
## Características
* Genera entradas adaptadas a tu código real
* Recolección opcional de corpus, mutación y guía de cobertura para encontrar bugs más profundos
* Impulsado por [Slither](https://github.com/crytic/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 quedan cubiertas tras la campaña de fuzzing
* Interfaz de terminal interactiva, salida solo de texto o JSON
* Minimización automática de casos de prueba para un triaje rápido
* Integración perfecta en el flujo de trabajo de desarrollo
.. y [un bonito logo artesanal de alta resolución](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
### Ejecutar el ejecutor de pruebas
La funcionalidad principal de Echidna es un ejecutable llamado `echidna`, que toma un contrato y una lista
de invariantes (propiedades que siempre deben permanecer verdaderas) como entrada. Para cada invariante, genera
secuencias aleatorias de llamadas al contrato y comprueba si el invariante se cumple. Si encuentra alguna forma
de falsificar el invariante, imprime la secuencia de llamadas que lo hace. Si no puede, tienes cierta
garantía de que el contrato es seguro.
### Escribir invariantes
Los invariantes se expresan como funciones de Solidity con nombres que comienzan por `echidna_`, no tienen argumentos y devuelven un booleano. Por ejemplo, si tienes alguna variable `balance` que nunca debería 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 verificar estas invariantes, ejecute:```sh
$ echidna myContract.sol
```
Un ejemplo de contrato con pruebas se puede encontrar en [tests/solidity/basic/flags.sol](https://github.com/crytic/echidna/blob/master/tests/solidity/basic/flags.sol). Para ejecutarlo, debes ejecutar:```sh
$ echidna tests/solidity/basic/flags.sol
```
Echidna debería encontrar una secuencia de llamadas que falsifique `echidna_sometimesfalse` y no debería poder encontrar una entrada falsificante para `echidna_alwaystrue`.
### Modos de prueba
El ejemplo anterior utiliza 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 de los helpers `assertX` de Foundry (`assertTrue`, `assertEq`, etc.).
* **`foundry`**: Ejecuta pruebas al estilo Foundry, siguiendo sus convenciones de nomenclatura: pruebas unitarias y de fuzzing con prefijo `test` (se espera que las que tienen prefijo `testFail` reviertan) e invariantes con estado con prefijo `invariant` o `statefulFuzz`. Las funciones con prefijo `check` y `prove` son puntos de entrada simbólicos, pero como este modo es una campaña de fuzzing, se someten a fuzzing como cualquier otra función de prueba.
* **`verification`**: Verifica simbólicamente cada función del contrato utilizando una única transacción. Las funciones con prefijo `check` y `prove` siempre se utilizan como puntos de entrada.
* **`overflow`**: Detecta desbordamientos/subdesbordamientos de enteros (Solidity >= 0.8.0).
* **`optimization`**: Maximiza el valor de retorno de las funciones con prefijo `echidna_` que devuelven `int256` (utiliza el mismo prefijo configurable que el modo property).
* **`exploration`**: Recopila cobertura sin comprobar propiedades.
### Recopilación y visualización de la cobertura
Tras 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á unos cuantos archivos de 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 out-of-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, incluidos [Foundry](https://book.getfoundry.sh/), [Hardhat](https://hardhat.org/) y [Truffle](https://archive.trufflesuite.com/), usando [crytic-compile](https://github.com/crytic/crytic-compile). Para invocar Echidna con el framework de compilación actual, use `echidna .`.
Además de eso, Echidna admite dos modos para probar contratos complejos. En primer lugar, se puede [aprovechar el estado de red existente](https://secure-contracts.com/program-analysis/echidna/advanced/state-network-forking.html) y usarlo como estado base para Echidna. En segundo lugar, Echidna puede llamar a cualquier contrato con una ABI conocida pasando el código fuente 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](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial) contiene un curso intensivo sobre Echidna, que incluye ejemplos, lecciones y ejercicios.
### Uso de Echidna en un flujo de trabajo de GitHub Actions
Existe 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](https://github.com/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/master/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. Está el controlador `text`
predeterminado, un controlador `json` y un controlador `none`, que debería suprimir toda
la salida de `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 incrementan la cobertura. Estas interfaces están sujetas a cambios para ser ligeramente 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 los valores `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, añade `+RTS -p -s` a tu 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 el perfilado básico no ayuda, puedes usar [técnicas de perfilado más avanzadas](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 usadas en rutas críticas
Comprobar esto es un buen punto de partida. Si sospechas que algún cálculo es demasiado perezoso y
filtra 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
estas se heredan 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 listamos aquí incluyendo su
issue correspondiente y el estado ("wont fix", "on hold", "in review", "fixed"). Los issues que están
"fixed" se espera que se incluyan en la próxima versión de Echidna.
| Descripción | Issue | Estado |
| :--- | :---: | :---: |
| El soporte de Vyper es limitado | [#652](https://github.com/crytic/echidna/issues/652) | *wont fix* |
| Soporte limitado de librerías para pruebas | [#651](https://github.com/crytic/echidna/issues/651) | *wont fix* |
## Instalación
### Binarios precompilados
Antes de empezar, asegúrate de que Slither esté [instalado](https://github.com/crytic/slither) (`pip3 install slither-analyzer --user`).
Si quieres probar Echidna rápidamente en Linux o MacOS, proporcionamos binarios de Linux enlazados estáticamente compilados en Ubuntu y binarios de MacOS mayormente estáticos en nuestra [página de releases](https://github.com/crytic/echidna/releases). También puedes obtener el mismo tipo de binarios desde nuestro [CI pipeline](https://github.com/crytic/echidna/actions?query=workflow%3ACI+branch%3Amaster+event%3Apush), solo haz clic en el commit para encontrar binarios para Linux o MacOS.
### Homebrew (macOS / Linux)
Si tienes Homebrew instalado en tu máquina Mac o Linux, puedes instalar Echidna y todas sus dependencias (Slither, crytic-compile) ejecutando `brew install echidna`.
También puedes compilar e instalar el código más reciente de la rama `master` ejecutando `brew install --HEAD echidna`
Puedes obtener más información en la página de la [fórmula de Homebrew de `echidna`](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 de
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á pensado para ser una imagen pequeña pero lo suficientemente flexible para usar
Echidna. Proporciona una versión precompilada 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 construyen en sistemas x86. Ejecutarlas
en dispositivos ARM, como sistemas Mac M1, no se recomienda debido a la pérdida de rendimiento
que supone la emulación de CPU.
Hay diferentes etiquetas disponibles para la imagen del contenedor Docker:
| Etiqueta | Build en la etiqueta
|---------------|-------------
| `vx.y.z` | Build correspondiente al release `vx.y.z`
| `latest` | Último release etiquetado de Echidna.
| `edge` | Commit más reciente en la rama por defecto.
| `testing-foo` | Build de prueba basado 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
```
En caso contrario, si quieres compilar localmente la última versión de Echidna, recomendamos usar Docker. Desde dentro de un clon de este repositorio, ejecuta el siguiente comando para compilar 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 las pruebas integrales 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
```
### Compilación 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 (compilada con recovery habilitado), que 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 de CI](https://github.com/crytic/echidna/blob/master/.github/scripts/install-libff.sh) para orientarte.
Algunas distribuciones de Linux no incluyen bibliotecas estáticas para ciertas cosas que Haskell necesita, por ejemplo Arch Linux, lo que hará que `stack build` falle con errores de enlazado porque usamos la bandera `-static`. En ese caso, usa `--flag echidna:-static` para producir un binario enlazado dinámicamente.
Si obtienes errores de compilación relacionados con el enlazado, intenta ajustar `--extra-include-dirs` y `--extra-lib-dirs`.
### Compilación 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 los 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
```
### Ejecución de las suites de pruebas
`cabal run tests` es la suite de Haskell, y cubre todo lo que Echidna hace en
proceso.
El servidor MCP se prueba fuera de proceso en su lugar, iniciando una campaña real y
dirigiéndola tal como lo haría un cliente agente. Esa suite es de Python, y necesita un
`echidna` en `$PATH`:```sh
$ pip install -r tests/mcp/requirements-test.txt
$ pytest tests/mcp -v
```
Apúntalo a una campaña que hayas iniciado tú mismo con `ECHIDNA_MCP_URL`, a un
puerto diferente con `ECHIDNA_MCP_PORT`, o a un binario específico con
`ECHIDNA_BIN`. Un ejemplo de un agente dirigiendo una campaña a través de la misma
interfaz está en [examples/](https://github.com/crytic/echidna/blob/master/examples/README.md).
## 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 parcialmente completada con cero, entonces puede ser parcialmente completada 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 conduce a tokens de pool gratuitos | Jan 2020
[Balancer Core](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) | Llamar a exitswapExternAmountOut no conduce a activos gratuitos | Jan 2020
[Liquity Dollar](https://github.com/trailofbits/publications/blob/master/reviews/Liquity.pdf) | [Cerrar troves requiere mantener la cantidad total de LUSD acuñada](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 balances 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 para mostrar con qué rapidez puede encontrar la solución. Todos estos pueden resolverse, en unos pocos 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 | Evento | 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 trabajo académico, considera postularte al [Crytic $10k Research Prize](https://blog.trailofbits.com/2019/11/13/announcing-the-crytic-10k-research-prize/).
## Obtener ayuda
No dudes en pasar por nuestro canal de slack #ethereum en [Empire Hacking](https://slack.empirehacking.nyc/) para obtener ayuda sobre el uso o la extensión de Echidna.
* Comienza revisando estos sencillos [invariantes de Echidna](https://github.com/crytic/echidna/blob/master/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).