Vés al contingut
BCTI
Tots els articles

Fuzzing o verificació formal: quanta garantia necessita el vostre protocol?

La revisió manual, el fuzzing d’invariants i la verificació formal troben errors diferents. Què demostra realment cada tècnica, on no arriba i com combinar-les.

Publicat: 4 min de lectura

També disponible en: Español · English

Un contracte intel·ligent és el pitjor tipus de programari on es pot cometre un error. El codi és públic i custodia diners reals. Qualsevol el pot cridar en qualsevol ordre, i un cop desplegat, corregir-lo és lent en el millor dels casos i impossible en el pitjor.

Una revisió manual acurada és imprescindible, però té un punt cec. Les persones som molt bones detectant lògica defectuosa i mal disseny. En canvi, no som bones explorant totes les seqüències possibles de transaccions. Els errors que buiden protocols acostumen a viure en aquest espai: un error d’arrodoniment que només importa després d’una donació, o un estat al qual només s’arriba després de cinc crides concretes.

Aquí entren el fuzzing i la verificació formal. Sovint se’n parla alhora, però responen preguntes diferents.

Comenceu pels invariants

Totes dues tècniques us demanen el mateix: una definició precisa del que s’ha de complir sempre. Són els invariants del vostre protocol, i escriure’ls ja és la meitat del valor de l’exercici. Alguns exemples típics:

  • Solvència: el contracte sempre té com a mínim tants tokens com deu als usuaris.
  • Conservació: les participacions de tots els usuaris sumen el subministrament total.
  • Control d’accés: només el timelock de governança pot canviar les comissions.
  • Cap valor gratuït: dipositar i retirar immediatament mai no retorna més del que s’ha dipositat.

Si el vostre equip no és capaç d’escriure’ls, això ja és una troballa.

Fuzzing: intentar trencar-ho milions de vegades

Un fuzzer d’invariants (Foundry, Echidna o Medusa, per exemple) crida els vostres contractes amb entrades aleatòries i en ordre aleatori. Després de cada crida, comprova que els invariants es continuen complint. Els handlers fan que les crides siguin realistes: limiten les entrades i registren el que hauria d’haver passat 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());
    }
}

Quan un invariant es trenca, el fuzzer informa de la seqüència exacta de crides que l’ha trencat i la redueix a la versió més curta. Obteniu un atac reproduïble, no una teoria.

Punts forts: és ràpid de preparar, barat d’executar a cada commit, i cada fallada és concreta.

Límits: només explora les entrades que prova. Una condició que depèn d’un valor concret de 256 bits, o un estat situat a vint crides de profunditat, pot sobreviure a milions d’execucions. Una campanya llarga sense errors és una evidència sòlida, però no és una demostració.

Verificació formal: demostrar-ho per a qualsevol entrada

La verificació formal no prova entrades una per una: raona sobre totes alhora. Les eines d’execució simbòlica, com Halmos i hevm, tracten les entrades com a variables matemàtiques i pregunten a un solucionador si algun valor pot fer fallar una asserció. Halmos reutilitza la sintaxi dels tests de Foundry, de manera que una propietat 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
}

Els demostradors com el Certora Prover van més enllà. Les regles s’escriuen en un llenguatge d’especificació propi i es comproven contra el bytecode compilat. A més, poden quantificar sobre totes les funcions d’un contracte.

Punts forts: quan una propietat queda demostrada, es compleix per a qualsevol entrada i estat que cobreix el model. Si no, obteniu un contraexemple concret.

Límits: una demostració només és tan bona com la seva especificació i els seus supòsits. Els bucles normalment només es comproven fins a un límit fix. Els contractes externs s’han de modelar. El codi gran o amb molta matemàtica pot esgotar el temps. La verificació formal demostra el que heu escrit, no el que volíeu dir.

Cara a cara

Aspecte Revisió manual Fuzzing d’invariants Verificació formal
Pregunta que respon El disseny és sòlid? Puc trencar aquesta propietat? Aquesta propietat es pot trencar mai?
Cobertura El que analitzen els auditors Entrades i seqüències mostrejades Totes les entrades, dins dels límits establerts
Resultat Troballes i recomanacions Contraexemples minimitzats Demostracions o contraexemples
Limitació principal L’atenció humana No pot demostrar l’absència d’errors Depèn de la qualitat de l’especificació
Ideal per a Lògica, economia, integracions Invariants de tot el protocol Matemàtica i comptabilitat crítiques

Com les combinem

A les nostres auditories, les tres capes es complementen:

  1. Primer, revisió manual. Entenem com es mou el valor pel protocol i escrivim els invariants amb els vostres desenvolupadors.
  2. Fuzzing de tot el sistema contra aquests invariants: Foundry per iterar ràpid, i Echidna i Medusa per a campanyes llargues.
  3. Verificació formal del nucli, és a dir, el codi on una fallada seria catastròfica: la comptabilitat de participacions, les biblioteques matemàtiques i el control d’accés de les actualitzacions.
  4. Tot queda al vostre repositori, executant-se a la CI, perquè el canvi següent també es comprovi.

Cap d’aquestes tècniques no substitueix les altres. A més, totes tres s’aturen a la frontera del contracte. Un vault perfectament verificat no serveix de res si un frontend compromès demana als usuaris que signin una transacció maliciosa. Per això també provem la capa Web 2.5 que envolta els contractes.

Si esteu preparant un llançament o una actualització, expliqueu-nos el vostre protocol.

Fins a quin punt esteu exposats?

Expliqueu-nos com és el vostre protocol o el vostre entorn i us proposarem un projecte a mida.

Parlem-ne