Rust contro i bug di Memoria del Firmare. Riscrivere in logica Shim le librerie è la chiave

Redazione RHC : 12 Settembre 2024 07:17

Google ha sostenuto l’implementazione di Rust nel firmware di basso livello, promuovendo la traduzione del codice legacy come mezzo per combattere i bug che minacciano la sicurezza dell’accesso alla memoria.

In un nuovo post sul blog, il team di Android sostiene che il passaggio da C o C++ a Rust nel firmware esistente fornirà garanzie di sicurezza della memoria a livelli inferiori al sistema operativo che non dispone di standard di sicurezza.

Secondo gli esperti, la perdita di produttività in questo caso è trascurabile, anche la dimensione dei codici Rust è comparabile, l’importante è sostituire i codici base per gradi, iniziando con quelli nuovi e più critici. Il processo non richiederà molti sforzi e nel tempo il numero di vulnerabilità di accesso alla memoria sarà significativamente ridotto.

Riscrivere gradualmente il codice delle librerie utilizzando la logica Shim

Per facilitare la transizione, è possibile ad esempio, creare un sottile strato Rust, il preloader Shim , che copierà l’API C ed esporterà per la base di codice esistente. “Shim funge da wrapper attorno all’API della libreria Rust, collegando l’API C esistente e l’API Rust”, spiegano gli esperti. “Questo è quello che si fa di solito, riscrivendo le librerie o sostituendole con un’alternativa a Rust.”

Secondo Google, fino a poco tempo fa, i bug di sicurezza nella memoria erano la principale fonte di vulnerabilità in Chrome e Android. Grazie all’implementazione di linguaggi di programmazione in grado di liberare i prodotti da questa piaga, tra il 2019 e il 2022 il numero annuo di tali errori nel sistema operativo mobile è stato ridotto da 223 a 85.

L’anno scorso, Microsoft ha avviato il processo di migrazione del kernel di Windows su Rust.

La versione 11 della build del sistema operativo, rilasciata a maggio 2023, conteneva driver in questo linguaggio. Allo stesso tempo, si è saputo dei piani del colosso tecnologico per aumentare in modo simile la sicurezza del processore Pluton, che non ha ancora trovato un utilizzo diffuso.

Rust la chiave dei bug di memoria

Il linguaggio di programmazione Rust è stato progettato per risolvere problemi legati alla sicurezza della memoria e alla gestione concorrente dei dati, affrontando alcune delle vulnerabilità più comuni presenti in linguaggi come C e C++. Ecco i principali tipi di bug che Rust risolve:

1. Bug di gestione della memoria (Memory Safety Issues)

• Dereferenziazione di puntatori nulli (Null Pointer Dereference): In linguaggi come C e C++, è comune che i puntatori nulli causino crash del programma o comportamenti imprevisti. Rust previene questo problema usando il tipo Option, che fornisce un modo sicuro di gestire valori che potrebbero essere nulli.
• Use-After-Free: Questo bug si verifica quando un programma tenta di accedere a un’area di memoria che è già stata liberata. In Rust, grazie al sistema di proprietà (ownership) e al concetto di borrow checker, non è possibile accedere alla memoria dopo che è stata rilasciata.
• Double Free: In C o C++, liberare la stessa area di memoria due volte può causare instabilità o vulnerabilità. Rust gestisce la liberazione della memoria in modo automatico e sicuro attraverso la sua gestione di ownership, prevenendo il rischio di liberazioni multiple della stessa risorsa.

2. Race conditions e problemi di concorrenza (Concurrency Bugs)

• Data Race: Una data race si verifica quando due thread accedono contemporaneamente alla stessa memoria, con almeno uno che esegue un’operazione di scrittura, senza la necessaria sincronizzazione. Rust usa tipi come Mutex e RwLock, e il borrow checker assicura che le risorse condivise siano accessibili in modo sicuro, prevenendo le data race a compile-time.
• Thread Safety: Rust applica rigorose regole di concorrenza e sincronizzazione attraverso il sistema di tipi, assicurandosi che le risorse condivise tra thread siano sicure da usare.

3. Buffer overflow

• Questo è uno dei bug di sicurezza più comuni in linguaggi come C e C++, dove l’accesso a buffer di memoria oltre i limiti definiti può causare comportamenti imprevisti o vulnerabilità di sicurezza. Rust impedisce questo bug grazie al suo controllo rigoroso dei limiti degli array e delle slice, rendendo impossibile l’accesso fuori dai limiti a meno che non sia esplicitamente consentito.

4. Dangling Pointers

• Un dangling pointer è un puntatore che fa riferimento a una locazione di memoria che non è più valida. In Rust, il sistema di ownership impedisce la creazione di puntatori invalidi o di riferimenti a memoria liberata, eliminando i dangling pointers.

5. Memory Leaks

• Anche se Rust non garantisce di prevenire ogni perdita di memoria (poiché può esserci memoria ciclicamente referenziata che non viene rilasciata), è molto più difficile incorrere in memory leaks rispetto a linguaggi come C/C++. La gestione della memoria basata su ownership e il sistema di borrowing fanno sì che le risorse vengano rilasciate automaticamente quando non sono più utilizzate.

6. Errori di tipo (Type Safety Issues)

• Rust è un linguaggio fortemente tipizzato, e molte operazioni che in altri linguaggi potrebbero fallire a runtime vengono bloccate a compile-time. Questo impedisce errori legati al tipo di dati, come assegnare valori a variabili di tipo incompatibile o effettuare operazioni non valide tra tipi diversi.

7. Stack Overflow per ricorsione non controllata

• Rust include l’uso di tail-call optimizations per ridurre il rischio di overflow dello stack nelle funzioni ricorsive. Anche se non previene completamente il problema, il suo sistema di tipi e la gestione delle risorse rendono più facile evitare errori di questo tipo.

Redazione
La redazione di Red Hot Cyber è composta da un insieme di persone fisiche e fonti anonime che collaborano attivamente fornendo informazioni in anteprima e news sulla sicurezza informatica e sull'informatica in generale.