Ir al contenido
BCTI
Todos los artículos

Fuzzing o verificación formal: ¿cuánta garantía necesita su protocolo?

La revisión manual, el fuzzing de invariantes y la verificación formal encuentran fallos distintos. Qué demuestra realmente cada técnica, dónde no llega y cómo combinarlas.

Publicado: 4 min de lectura

También disponible en: Català · English

Un contrato inteligente es el peor tipo de software en el que equivocarse. El código es público y custodia dinero real. Cualquiera puede llamarlo en cualquier orden, y una vez desplegado, corregirlo es lento en el mejor de los casos e imposible en el peor.

Una revisión manual cuidadosa es imprescindible, pero tiene un punto ciego. Las personas somos muy buenas detectando lógica defectuosa y mal diseño. En cambio, no somos buenas explorando todas las secuencias posibles de transacciones. Los fallos que vacían protocolos suelen vivir en ese espacio: un error de redondeo que solo importa después de una donación, o un estado al que solo se llega tras cinco llamadas concretas.

Ahí entran el fuzzing y la verificación formal. A menudo se mencionan juntos, pero responden a preguntas distintas.

Empiece por los invariantes

Ambas técnicas le piden lo mismo: una definición precisa de lo que debe cumplirse siempre. Son los invariantes de su protocolo, y escribirlos ya es la mitad del valor del ejercicio. Algunos ejemplos típicos:

  • Solvencia: el contrato siempre tiene como mínimo tantos tokens como debe a los usuarios.
  • Conservación: las participaciones de todos los usuarios suman el suministro total.
  • Control de acceso: solo el timelock de gobernanza puede cambiar las comisiones.
  • Ningún valor gratuito: depositar y retirar inmediatamente nunca devuelve más de lo depositado.

Si su equipo no es capaz de escribirlos, eso ya es un hallazgo.

Fuzzing: intentar romperlo millones de veces

Un fuzzer de invariantes (Foundry, Echidna o Medusa, por ejemplo) llama a sus contratos con entradas aleatorias y en orden aleatorio. Después de cada llamada, comprueba que los invariantes se siguen cumpliendo. Los handlers hacen que las llamadas sean realistas: acotan las entradas y registran lo que debería haber pasado en variables «fantasma».

contract VaultInvariants is Test {
    MockERC20 asset;
    Vault vault;
    VaultHandler handler;

    function setUp() public {
        asset = new MockERC20();
        vault = new Vault(asset);
        handler = new VaultHandler(vault, asset);
        // The fuzzer calls random sequences of the handler's functions.
        targetContract(address(handler));
    }

    /// Solvency: the vault always holds at least what it owes.
    function invariant_solvent() public view {
        assertGe(asset.balanceOf(address(vault)), vault.totalDeposits());
    }

    /// Accounting matches every deposit and withdrawal the fuzzer made.
    function invariant_accounting() public view {
        assertEq(vault.totalDeposits(), handler.ghostDeposited() - handler.ghostWithdrawn());
    }
}

Cuando un invariante se rompe, el fuzzer informa de la secuencia exacta de llamadas que lo ha roto y la reduce a la versión más corta. Obtiene un ataque reproducible, no una teoría.

Puntos fuertes: es rápido de preparar, barato de ejecutar en cada commit, y cada fallo es concreto.

Límites: solo explora las entradas que prueba. Una condición que depende de un valor concreto de 256 bits, o un estado situado a veinte llamadas de profundidad, puede sobrevivir a millones de ejecuciones. Una campaña larga sin fallos es una evidencia sólida, pero no es una demostración.

Verificación formal: demostrarlo para cualquier entrada

La verificación formal no prueba entradas una a una: razona sobre todas a la vez. Las herramientas de ejecución simbólica, como Halmos y hevm, tratan las entradas como variables matemáticas y preguntan a un solucionador si algún valor puede hacer fallar una aserción. Halmos reutiliza la sintaxis de los tests de Foundry, así que una propiedad resulta familiar:

/// Halmos treats `user` and `amount` as symbolic: every possible value at once.
function check_withdrawNeverExceedsBalance(address user, uint256 amount) public {
    uint256 balanceBefore = vault.balanceOf(user);
    vm.prank(user);
    vault.withdraw(amount); // if this call does not revert…
    assert(amount <= balanceBefore); // …this must hold for every input
}

Los demostradores como el Certora Prover van más allá. Las reglas se escriben en un lenguaje de especificación propio y se comprueban contra el bytecode compilado. Además, pueden cuantificar sobre todas las funciones de un contrato.

Puntos fuertes: cuando una propiedad queda demostrada, se cumple para cualquier entrada y estado que cubre el modelo. Si no, obtiene un contraejemplo concreto.

Límites: una demostración solo es tan buena como su especificación y sus supuestos. Los bucles normalmente solo se comprueban hasta un límite fijo. Los contratos externos deben modelarse. El código grande o con mucha matemática puede agotar el tiempo. La verificación formal demuestra lo que ha escrito, no lo que quería decir.

Cara a cara

Aspecto Revisión manual Fuzzing de invariantes Verificación formal
Pregunta que responde ¿El diseño es sólido? ¿Puedo romper esta propiedad? ¿Puede romperse esta propiedad alguna vez?
Cobertura Lo que analizan los auditores Entradas y secuencias muestreadas Todas las entradas, dentro de los límites establecidos
Resultado Hallazgos y recomendaciones Contraejemplos minimizados Demostraciones o contraejemplos
Limitación principal La atención humana No puede demostrar la ausencia de fallos Depende de la calidad de la especificación
Ideal para Lógica, economía, integraciones Invariantes de todo el protocolo Matemática y contabilidad críticas

Cómo las combinamos

En nuestras auditorías, las tres capas se complementan:

  1. Primero, revisión manual. Entendemos cómo se mueve el valor por el protocolo y escribimos los invariantes con sus desarrolladores.
  2. Fuzzing de todo el sistema contra esos invariantes: Foundry para iterar rápido, y Echidna y Medusa para campañas largas.
  3. Verificación formal del núcleo, es decir, el código en el que un fallo sería catastrófico: la contabilidad de participaciones, las bibliotecas matemáticas y el control de acceso de las actualizaciones.
  4. Todo queda en su repositorio, ejecutándose en la CI, para que el siguiente cambio también se compruebe.

Ninguna de estas técnicas sustituye a las demás. Además, las tres se detienen en la frontera del contrato. Un vault perfectamente verificado no sirve de nada si un frontend comprometido pide a los usuarios que firmen una transacción maliciosa. Por eso también probamos la capa Web 2.5 que rodea los contratos.

Si está preparando un lanzamiento o una actualización, cuéntenos cómo es su protocolo.

¿Hasta qué punto está expuesto?

Cuéntenos cómo es su protocolo o su entorno y le propondremos un proyecto a medida.

Hablemos