Echidna: Un fuzzer rápido para contratos inteligentes

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 para falsificar predicados definidos por el usuario o aserciones de Solidity. 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 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.

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. 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, Hardhat y Truffle, usando 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 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 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 para obtener instrucciones de uso y ejemplos.

echidna v2.3.3