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
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:
- Primero, revisión manual. Entendemos cómo se mueve el valor por el protocolo y escribimos los invariantes con sus desarrolladores.
- Fuzzing de todo el sistema contra esos invariantes: Foundry para iterar rápido, y Echidna y Medusa para campañas largas.
- 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.
- 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.