Recuperare file WAV da SD Card Formattata

E' capitato a tutti di formattare una SD per errore. Fortunatamente con i vari software per il recupero di file cancellati nella maggior parte dei casi si riescono a recuperare i file senza alcun problema, siano essi fotografie o video.
Vediamo nello specifico cosa avviene durante la formattazione FAT su un dispositivo e affrontiamo un caso eccezionale, la frammentazione sincrona di un flusso audio multistream generato da un hardware per podcast.

Come vengono memorizzati i file su File System FAT

La FAT è un file system arcaico con una struttura molto semplificata.
Ogni oggetto nella FAT è legato ad un cluster ( gruppo di settori ) che identifica tanto una directory quanto un file.
I file vengono allocati nella tabella FAT con una sequenza di puntatori a 32 bit che si riferiscono al cluster successivo.
La seguente formula consente al sistema operativo di determinare la posizione del file e la sua allocazione.

Localizzazione del record di fat per il cluster 100 ( esempio)

uint32_t    cluster_richiesto = 100;

uint32_t    offset = cluster_richiesto * sizeof(uint32_t);

int64_t    relative_sector = ( ( cluster_richiesto * sizeof(uint32_t) ) / 512 )   + fat_block_start +  fat_offset;

uint32_t   module = offset % 512;

a questo punto abbiamo localizzato la posizione del primo cluster nella tabella e possiamo iniziare la reiterazione della FAT.

Reiterazione dei cluster associati al cluster iniziale:

while ( ! IsEndOfChain(value) )
{
        value = GetFatEntry( value  );
        AllocatedClusters++;

}

Cosa avviene durante il processo di formattazione della card

Se formattiamo la card, tutti i record presenti nella FAT vengono azzerati danneggiando le sequenze di frammentazione in modo definitivo. Nella memoria, tuttavia rimarranno le persistenze delle cartelle e i file esattamente come erano e dove erano memorizzati in precedenza.

Come recuperare i dati da card formattata ( approfondimento tecnico )

Anche se la FAT è danneggiata, le directories ancora presenti nella card possono essere utilizzate per ricostruire l'ordine e la struttura originaria e salvare i file in modalità "guessed", ovvero presumendo che siano contigui utilizzando come start il valore cluster memorizzato nella directory "entry" localizzata e come dimensione massima il valore di dimensione del file in bytes presente nella directory stessa.
Esistono centinaia di software che sono in grado di fare questo lavoro di ricostruzione e risultano efficaci nella maggioranza dei casi.

Un caso limite: Formattazione di una card utilizzata con RoadCaster

In un caso reale limite, il nostro committente ha inserito per errore una SD card utilizzata per registrare puntate di un Podcast in una Playstation Vita danneggiando il file system in modo severo, e successivamente ha riformattato la stessa card con un iMac: Una catastrofe.

La card conteneva dei podcast registrati pronti per la messa in onda.
I primi tentativi di ripristinare i file, condotti con software di recupero dati hanno prodotto il recupero di file wav completamente danneggiati.

Analisi dei file system presenti nella card

Lo scenario della card in oggetto è catastrofico, esistono infatti 3 file system miscelati in overlap (  EXFAT / FAT32 / EXFAT by OSX)  ed è subito chiaro che il file system originale è stato completamente sovrascritto. Il layout delle partizioni risulta essere inoltre tipico degli schemi applicati da OSX, con la tipica partizione iniziale ad offset 40 di cui i progettisti di Cupertino non hanno mai realmente spiegato il significato.

E' tuttavia ancora possibile eseguire delle analisi sui metadati di file system, quantomeno per comprendere il contenuto originale e le posizioni di base dei clusters.

Analisi Forense e ricerca delle intestazioni . WAV

La ricerca forense di file per estensione risulta molto semplice per i file WAV, in quanto è sufficiente impostare il grep con il pattern RIFF per ottenere lo start dei file audio.

Una brutta sorpresa: i file localizzati sono completamente frammentati

Nel cruscotto di analisi di Challenger Rocket è possibile analizzare la sequenza delle catene cluster e la loro frammentazione ordinata per offset di un campione di analisi di scrittura eseguito con RoadCaster.
Dalla mappa dei file presenti ( dove la FAT è funzionante ) è evidente che il RoadCaster accodi simultaneamente 5 file in modo parallelo costringendo il driver FAT a frammentare le sequenze.

Data Carving in pillole: come vengono determinate le posizioni e le dimensioni dei file cancellati

In un contesto di analisi basata su file carving, la localizzazione di un file avviene per grep della firma tipica del file e la dimensione viene calcolata in base allo start di file successivo. Tale metodo risulta efficace in tutti i casi in cui il file sia riconscibile con una estensione tipica e non presenti frammentazione.

Game Over ? Ancora no per fortuna.

Arrendersi per una "semplice" formattazione e sovrascrittura ? Forse No.
Abbiamo dunque teorizzato la possibilitò di analizzare in real time le sequenze dei file WAV analizzando i due canali e i datasample a 24 bit.

Teoria del file carving euristico basato su analisi dei samples a 24 bit

Un datasample stereo a 24 bit occupa 6 bytes.
Nella teoria analizzando in modo reiterativo i blocchi frammentati nella card che sono memorizzati in dimensione fissa è possibile creare un buffer dinamico e testare il risultato in un parser riff.

Il parser rappresentato, non fa altro che analizzare un buffer e analizzare i sample a 24 bit.
Assumendo il fatto che una registrazione voce i due canali non possano avere nello stesso sample un valore molto diverso,
saremo in grado di scartare i sample dove esista una discrasia tra i due canali, scartando il buffer con una coda non congrua.
Il prototipo riceve semplicemente un buffer incrementale e ne verifica la quantità di samples. 
La regola per validare il flusso è la differenza numerica tra il sample del canale destro e sinistro.

uint16_t  bytes_per_sample = 3;

uint64_t  frame_size = bytes_per_sample * channels;

size_t total_frames = datasize / frame_size;

uint32_t module;

int32_t channel_differences=0;

    for (size_t i = 0; i < total_frames; ++i)

    {

        size_t frame_start = i * frame_size;

        AudioFrame current_frame;
        current_frame.channels.reserve(channels);
        for (int ch = 0; ch < channels; ++ch)

        {

            size_t sample_start = frame_start + (ch * bytes_per_sample);

            // Lettura dei 3 byte in formato Little-Endian

            uint8_t b0 = ptr[sample_start];     // LSB

            uint8_t b1 = ptr[sample_start + 1]; // Mid

            uint8_t b2 = ptr[sample_start + 2]; // MSB (contiene il segno)

            // 1. Ricostruzione dell'intero a 24-bit senza segno

            uint32_t value_24bit = b0 | (b1 << 8) | (b2 << 16);

            // 2. Estensione del segno a 32-bit (Sign Extension)

            // Se il 24° bit (0x800000) è 1, il numero è negativo.

            int32_t sample_32bit;

            if (value_24bit & 0x800000)

            {
                sample_32bit = static_cast<int32_t>(value_24bit | 0xFF000000); // Riempe di 1 i bit superiori
            }

            else

            {
                sample_32bit = static_cast<int32_t>(value_24bit);

            }

            file_offset +=3;

            current_frame.channels.push_back(sample_32bit);

        }

        checked_samples++;
    }

Struttura dei File WAV RIFF

I file RIFF sono molto semplici, dopo l'intestazione di 12 byte inizia una sequenza di metadati relativi al formato del file e la sequenza SampledData.
Nel caso che stiamo analizzando i sample sono 24 bit in modalità stereo.
24 bit in modalità stereo, corrisponde ad una sequenza di 6 byte per ogni sample.

[Master RIFF chunk]
    FileTypeBlocID  (4 bytes) : Identifier « RIFF »  (0x52, 0x49, 0x46, 0x46)
    FileSize        (4 bytes) : Overall file size minus 8 bytes
    FileFormatID    (4 bytes) : Format = « WAVE »  (0x57, 0x41, 0x56, 0x45)
 
[Chunk describing the data format]
    FormatBlocID    (4 bytes) : Identifier « fmt␣ »  (0x66, 0x6D, 0x74, 0x20)
    BlocSize        (4 bytes) : Chunk size minus 8 bytes, which is 16 bytes here  (0x10)
    AudioFormat     (2 bytes) : Audio format (1: PCM integer, 3: IEEE 754 float)
    NbrChannels     (2 bytes) : Number of channels
    Frequency       (4 bytes) : Sample rate (in hertz)
    BytePerSec      (4 bytes) : Number of bytes to read per second (Frequency * BytePerBloc).
    BytePerBloc     (2 bytes) : Number of bytes per block (NbrChannels * BitsPerSample / 8).
    BitsPerSample   (2 bytes) : Number of bits per sample
 
[Chunk containing the sampled data]
    DataBlocID      (4 bytes) : Identifier « data »  (0x64, 0x61, 0x74, 0x61)
    DataSize        (4 bytes) : SampledData size
    SampledData

Conclusioni e valutazioni Finali

La formattazione accidentale di una card puo' essere risolta con tool per il recupero della FAT con relativa semplicità.
E' tuttavia possibile che in casi particolari i file precedentemente memorizzati possano aver subito frammentazione sincrona.
Per poter recuperare file frammentati da una card formattata non ci sono alternative che realizzare un algoritmo che collaudi tutte le combinazioni possibili testando la validità del risultato. Sicuramente sviluppare parser così sofisticati rappresenta una sfida importante, ma è comunque praticabile se i dati sono realmente rilevanti.