Test e verifica formale per la sicurezza del contratto intelligente Web3

Ripubblicato da Platone

Seguaci: 0

Test e verifica formale per Web3 Smart Contract Security PlatoBlockchain Data Intelligence. Ricerca verticale. Ai.

Tempo per leggere: 9 verbale

Immagina di fare paracadutismo. Prima di saltare giù dall'aereo, controllerai il tuo paracadute un centinaio di volte, giusto? Il controllo e il collaudo sono parte integrante della sicurezza; pensare a qualsiasi cosa relativa alla sicurezza. Probabilmente ci sarebbe un meccanismo di test successivo, che si tratti dell'installazione di telecamere a circuito chiuso o del controllo dell'inchiostro a penna prima di un esame scritto a scuola, seguiamo tutti le misure di sicurezza. Maggiore è il rischio, più testiamo le cose. E quando parliamo di contratti intelligenti, il rischio è ENORME. Non puoi essere negligente quando si tratta di sicurezza del contratto intelligente.

1. La sicurezza è sempre necessaria.

Puoi sicuramente chiudere la porta due o tre volte, non importa. Puoi essere sicuro che la tua casa non possa essere svaligiata mentre sei via? Non puoi perché non sai cosa potrebbe fare il ladro per entrare in casa, lo stesso vale per ogni misura di sicurezza che adottiamo. Non esiste un metodo completamente sicuro che garantisca la sicurezza. Tuttavia, l'azione che intraprendiamo rapidamente aumenta le nostre possibilità di essere al sicuro, che è il gioco. Vogliamo aumentare le probabilità di essere al sicuro utilizzando misure diverse.

Il mondo di Web3 non è diverso. Non esiste un metodo sicuro per salvarti, ma avere auditor esperti di QuillAudits può aumentare enormemente le probabilità che il tuo protocollo venga protetto e garantirà la tua sicurezza aggiornata. In web3, ci sono due meccanismi importanti che ti aiutano a capire quanto sei sicuro facendo alcuni test sul tuo protocollo:-

Test del contratto intelligente
Verifica formale degli Smart Contract

Comprendiamoli in dettaglio e scopriamo come ci aiutano a conoscere i punti deboli o le vulnerabilità dei nostri contratti.

2. Test del contratto intelligente

Uno sviluppatore esperto può spiegare il lavoro a una macchina con il codice. Tuttavia, a volte la macchina non rappresenta l'esatto meccanismo che lo sviluppatore aveva in mente a causa di un difetto o di un errore logico nel codice. Il test è il processo che aiuta a identificare dove il nostro codice non funziona e cosa si può fare per farlo corrispondere all'azione che ci serve per eseguire.

Test del contratto intelligente è una fase del ciclo di sviluppo in cui eseguiamo un'analisi dettagliata dei nostri contratti e proviamo a scoprire dove e perché il nostro codice non funziona. Quasi tutti gli smart contract subiscono questa fase. Esistono due modi in cui viene eseguito il test del contratto intelligente. Esploriamoli.

2.1 Automatizzato

Come suggerisce il nome, questo metodo per testare i contratti intelligenti viene utilizzato per eseguire test con script. Si tratta di un software automatizzato che esegue test ripetuti per trovare eventuali vulnerabilità e difetti negli smart contract. Questi strumenti di test automatizzati possono essere configurati con dati di test e risultati previsti. Quindi il risultato effettivo viene confrontato con quelli previsti per verificare se il contratto funziona correttamente. I test automatizzati possono essere ulteriormente classificati in tre categorie.

2.1.1. Test funzionali

Supponiamo di scrivere un programma per prendere due numeri, aeb e quindi restituire l'addizione di entrambi i numeri. Quindi, per controllare quel programma, dai 2 e 8 e fornisci il risultato atteso come 10. Ora, quando il programma viene eseguito, dovrebbe anche restituire 10. Se lo fa, allora funziona bene e il nostro codice è corretto, ma se lo fa non, allora c'è qualche errore con il nostro codice.

I test funzionali richiedono la comprensione di come dovrebbe comportarsi il contratto in determinate condizioni. Possiamo testarlo eseguendo un calcolo con valori selezionati e confrontando l'output restituito. Il test funzionale ha tre classi: -

Test unitari:- Si tratta di testare la correttezza dei singoli componenti del contratto intelligente. È assertivo o richiede dichiarazioni sulle variabili.

integrazione Testino: – Questi si occupano di testare diversi singoli componenti insieme. Il test di integrazione è un livello più alto nella gerarchia rispetto al test unitario. Ci aiuta a determinare gli errori derivanti dall'interazione di diverse funzioni, che possono far parte di altri contratti intelligenti.

Sistema provano: – Questo è il più alto nella gerarchia. In questo, testiamo l'intero contratto come un sistema completamente integrato per vedere se funziona secondo le nostre esigenze. È fatto dal punto di vista dell'utente e il modo migliore per farlo è distribuirlo su testnet.

2.1.2. Analisi statica

L'analisi statica può essere eseguita senza nemmeno eseguire il programma. Implica l'analisi del codice sorgente o del bytecode dello smart contract prima dell'esecuzione. Dando così il suo nome, l'analisi statica può portare al rilevamento di alcune vulnerabilità comuni.

2.1.3. Analisi dinamica

A differenza dell'analisi statica, l'analisi dinamica viene eseguita durante il runtime degli smart contract per identificare i problemi nel codice. Gli analizzatori dinamici del codice osservano lo stato di esecuzione del contratto e generano un rapporto dettagliato delle vulnerabilità e delle violazioni della proprietà. Il fuzzing rientra nell'analisi dinamica. Il fuzzing sta alimentando un input errato o dannoso per causare l'esecuzione di codice involontario.

Manuale 2.2

Come suggerisce il nome, questo metodo di test del contratto intelligente prevede un'interazione regolare con uno sviluppatore umano. Gli audit del codice, in cui gli sviluppatori passano attraverso righe di codice, rientrano nella modalità manuale del test del contratto intelligente.

La modalità manuale richiede molto tempo, abilità, denaro e impegno. Tuttavia, il risultato spesso ne vale la pena perché, con questo, identifichiamo le vulnerabilità che potrebbero passare inosservate nei test automatici. Esistono due tipi essenziali di test manuali: -

2.2.1 Verifiche del codice:-

Il modo migliore per verificare se la tua misura di sicurezza funziona correttamente è provare a romperla. Ad esempio, se vuoi verificare se la serratura della tua auto funziona correttamente, prova a romperla. Ora potresti chiedere che un abile ladro d'auto possa facilmente irrompere nella mia macchina. Forse no, quindi la soluzione è assumere qualcuno esperto nell'irruzione in modo che possa guidarti!

Sì, sto parlando di QuillAudits. Siamo un team di revisori qualificati che possono guidarti. Gli audit del codice richiedono una mentalità da attaccante per trovare tutte le possibili vulnerabilità nel codice sorgente. Un audit del codice è una valutazione dettagliata del codice di uno smart contract per scoprire potenziali vulnerabilità e difetti.

2.2.2 Taglia Bug:-

Se pensi che ci possano essere delle falle di sicurezza nel tuo codice sorgente (che per lo più lo sono) e non riesci a trovarle, puoi esternalizzare questo lavoro a dei freelance creando un sistema di ricompensa. È più come annunciare una ricompensa per chiunque riesca ad hackerare il tuo contratto intelligente. In questo modo, impari a conoscere la vulnerabilità presente nel tuo contratto intelligente in modo da poterlo proteggere meglio e salvare i tuoi utenti dalla perdita.

3. Verifica formale degli Smart Contract

La verifica formale è il processo di valutazione della correttezza di un contratto basato su specifiche formali. Ciò significa che la verifica formale valuta se il codice fa ciò che è previsto. La verifica formale utilizza metodi formali per specificare, progettare e verificare i programmi.

3.1 Qual è la specifica formale?

Nel contesto degli smart contract, le specifiche formali si riferiscono alle proprietà che devono rimanere le stesse in ogni possibile circostanza. Si tratta di proprietà “invarianti” perché non possono cambiare e rappresentano asserzioni logiche sull'esecuzione del contratto.

La specifica formale è una raccolta di dichiarazioni scritte in un linguaggio formale. Le specifiche coprono diverse proprietà e descrivono come dovrebbero comportarsi le proprietà del contratto in altre circostanze. Le specifiche formali sono fondamentali perché se i contratti non hanno variabili invarianti o le proprietà cambiano durante l'esecuzione, può portare a un possibile sfruttamento della proprietà, che può portare a un'enorme perdita.

Può aiutarci a determinare se uno smart contract soddisfa le specifiche o presenta comportamenti imprevisti. La verifica formale ha tre componenti: una specifica, un modello e un motore di verifica.

3.1.1 Specifiche

Una specifica è una descrizione chiara, univoca e completa dei requisiti per uno smart contract. Dovrebbe descrivere cosa dovrebbe fare il contratto e cosa non dovrebbe fare. Ecco una specifica di esempio per un contratto semplice e intelligente che aggiunge due numeri:

// Specification: Adds two numbers
// Inputs: a, b (uint)
// Outputs: the sum of a and b (uint) function add(uint a, uint b) public view returns (uint) {
// Implementation details are not relevant to the specification
// …
}

3.1.2 Modello

Un modello rappresenta formalmente lo smart contract che può essere utilizzato per ragionare sul suo comportamento. Un modello popolare per i contratti intelligenti è il linguaggio di programmazione Solidity. Ecco un modello di esempio per la funzione add descritta sopra:

// Model: Adds two numbers
// Inputs: a, b (uint)
// Outputs: the sum of a and b (uint) function add(uint a, uint b) public view returns (uint) {
return a + b;
}

3.1.3 Motore di verifica

Un motore di verifica è uno strumento in grado di analizzare un modello e verificarne la correttezza rispetto a una data specifica. Sono disponibili diversi motori di verifica per i contratti intelligenti, tra cui:

Mithril: uno strumento di esecuzione simbolica open source in grado di rilevare un'ampia gamma di vulnerabilità di sicurezza nei contratti intelligenti Solidity.

IDE di remix: un ambiente di sviluppo integrato che include uno strumento di verifica formale in grado di verificare la correttezza degli smart contract.

Lievitatore della Certora: uno strumento commerciale in grado di verificare la correttezza dei contratti intelligenti utilizzando il ragionamento matematico automatizzato. Ecco un esempio di come la verifica formale può essere utilizzata per verificare la correttezza di uno smart contract utilizzando il Certora Prover:

pragma solidity 0.7.6; // Model: Adds two numbers
// Inputs: a, b (uint)
// Outputs: the sum of a and b (uint)
function add(uint a, uint b) public pure returns (uint) {
return a + b;
} // Model: Adds two numbers
// Inputs: a, b (uint)
// Outputs: the sum of a and b (uint) function add(uint a, uint b) public pure returns (uint) {
return a + b;
} // Specification: Adds two numbers
// Inputs: a, b (uint)
// Outputs: the sum of a and b (uint) function test_add(uint a, uint b) public pure returns (bool) {
uint expected = a + b;
uint actual = add(a, b);
return expected == actual;
} // Verification: Verify the correctness of the add function contract TestAdd {
function test_add(uint a, uint b) public view returns (bool) {
return CertoraProver.verify(test_add, a, b);
}
}

Nell'esempio precedente, definiamo uno smart contract Solidity che include un modello della funzione add, una specifica per la funzione e un motore di verifica (Certora Prover) in grado di verificare la correttezza della funzione. Definiamo anche una funzione di test (test_add) che può essere utilizzata per verificare la correttezza della funzione.

3.2 Test VS Verifica formale

Come abbiamo discusso, il test restituisce il risultato atteso per alcuni dati di input che mancano al bot perché non possiamo dire dei dati su cui non è stato testato. È praticamente impossibile verificarlo su ogni possibile input. Quindi non siamo sicuri della sua “correttezza funzionale”. È qui che entra in gioco la verifica formale. I metodi di verifica formale utilizzano rigorose tecniche matematiche per specificare e verificare software o contratti intelligenti.

3.3 Tecniche di verifica formale

La verifica formale ha un'ampia gamma di tecniche per il miglioramento sicurezza del contratto intelligente. In questa parte del blog, ne esploreremo alcuni individualmente.

3.3.1 Controllo del modello

Mentre abbiamo discusso di cosa sia una specifica formale, controlliamo lo smart contract rispetto alla sua specifica in questa tecnica di verifica formale. Questi contratti intelligenti sono rappresentati come sistemi di transizione di stato e le proprietà sono definite utilizzando la logica temporale.

Questa tecnica viene utilizzata principalmente per valutare le proprietà temporali che descrivono il comportamento degli smart contract nel tempo. Proprietà di controllo accessi (chiamata amministratore auto distruzione) può essere scritto come logica formale. Quindi l'algoritmo di verifica del modello può verificare se il contratto soddisfa questa verifica formale.

Il controllo del modello utilizza una tecnica chiamata esplorazione dello spazio di stato, che in pratica sta provando tutti i possibili stati in cui può trovarsi il nostro contratto intelligente e quindi verificando se qualcuno di essi si traduce in una violazione della proprietà. Tuttavia, questo può portare a infiniti stati; quindi i model checker si affidano a tecniche di astrazione per rendere possibile un'analisi efficiente dei contratti intelligenti.

3.3.2 Dimostrazione di teoremi

La dimostrazione di teoremi riguarda il ragionamento matematico sulla correttezza dei programmi. Si tratta di creare un'impressione logica del sistema e delle specifiche del contratto e di verificare l'“equivalenza logica” tra le affermazioni. L'equivalenza logica è una relazione matematica che afferma che l'affermazione A è vera se e solo se l'affermazione B è vera.

Come abbiamo appreso nella tecnica del model checking, modelliamo i contratti come sistemi di transizione con stati finiti. La dimostrazione di teoremi può gestire l'analisi di sistemi a stati infiniti. Tuttavia, un dimostratore di teoremi automatizzato non può sempre sapere se un problema logico è decidibile; quindi, l'assistenza umana è spesso richiesta per guidare il dimostratore di teoremi nel derivare dimostrazioni di correttezza.

4. CONCLUSIONE

I test e la verifica formale sono entrambi parti integranti dello sviluppo di contratti intelligenti. Questi sono i metodi utilizzati per rendere sicuri i contratti intelligenti e aiutare a preparare i contratti per la distribuzione. Ma si sa, la sicurezza non è mai abbastanza. Molti contratti intelligenti venivano violati solo perché non c'erano test adeguati. Ora più che mai la comunità web3 ha bisogno di protocolli più sicuri.

Noi di QuillAudits siamo in missione per aiutare a proteggere i tuoi protocolli. Con il nostro team competente ed esperto, ci assicuriamo che nemmeno una singola vulnerabilità passi inosservata. Visita il nostro sito Web e assicurati il tuo progetto Web3!

28 Visualizzazioni