La modifica di un file e il suo salvataggio sono sovrascritti in modo permanente?

Dipende dall'applicazione specifica. Alcune applicazioni sovrascriveranno solo il singolo blocco oi blocchi che hai modificato. Altri, più spesso, creano una nuova copia del file con un nuovo nome temporaneo, quindi lo rinominano, cancellando il vecchio file. Questo non è più "sicuro" della semplice eliminazione del file direttamente. Dovresti avere un'applicazione progettata specificamente per sovrascrivere l'intero file.

Nessuna di queste tecniche sovrascriverà l'intero file. Per fare ciò, dovrai sovrascrivere ogni blocco sul posto. Questo può essere fatto con strumenti specializzati come shred(1) . Nota che i filesystem moderni sono complessi e possono ancora esserci residui di dati rimasti. Ad esempio, ext4 può conservare piccoli file che si adattano a un singolo inode nello stesso inode. L'inode viene sottoposto a backup nel journal, che non viene sovrascritto quando l'inode viene sovrascritto. I filesystem che supportano copy-on-write come btrfs si comportano come gli SSD in quanto una singola scrittura su un determinato blocco non necessariamente sovrascrive il settore originale sull'unità in cui è memorizzato. L'unica vera soluzione per eliminare le informazioni sensibili è di tenerle crittografate e buttare via la chiave prima della cancellazione.

Modifica in loco

Un file è composto da un gran numero di settori , ciascuno di una dimensione come 512 byte. Un settore spesso (ma non sempre) le mappe di un blocco di file system, con un settore che è un'unità fisica di archiviazione dall'hardware del supporto di memorizzazione e un blocco di file system che è una singola unità di archiviazione come visto logicamente dal driver del filesystem. Una scrittura di settore è atomica (in teoria) e la modifica di un singolo byte richiede la scrittura nell'intero settore in cui si trova (sebbene il disco utilizzi read-modify-write per garantire che non vengano persi altri dati nel settore). La modifica di un file sul posto comporterà solo la sovrascrittura dei settori che contengono i dati modificati. Supponendo che tu stia usando un filesystem che non fa copy-on-write (su Linux, praticamente tutto tranne btrfs e ZFS), questo sovrascriverà solo i dati specifici che si stanno modificando.

Un'implementazione C che scrive una stringa sul byte 1234:

void edit(void)
{
    int fd = open("file.txt", O_RDWR);
    pwrite(fd, "Hello, world!", 13, 1234);

    fsync(fd);
    close(fd);
}

Modifica atomica

Spesso le applicazioni modificano i file creando un nuovo file con un nome temporaneo e popolandolo con i contenuti modificati del vecchio file. Dopo che è stato scritto (ed eventualmente sincronizzato su disco), viene rinominato con il nome originale, con la conseguente eliminazione del vecchio file, ma ancora presente sul disco. Questo è atomico , il che significa che il file è completamente modificato, o non modificato affatto. L'intenzione è quella di garantire che un sistema in crash che ha solo il tempo di fare una scrittura parziale non corromperà il file di destinazione. Rinominare è (o almeno dovrebbe essere) un'operazione atomica. Cioè, o riesce pienamente o fallisce, senza intermediari.

Un'implementazione C che copia il file e scrive una stringa sul 1234 ° byte:

void edit(void)
{
    int src_fd = open("file.txt", O_RDONLY);
    int dst_fd = open("file.txt.tmp", O_CREAT|O_RDWR);

    sendfile(dst_fd, src_fd, NULL, -1);
    pwrite(dst_fd, "Hello, world!", 13, 1234);

    fsync(dst_fd);
    rename("file.txt.tmp", "file.txt");

    close(src_fd);
    close(dst_fd);
}

Sovrascrittura locale

Per sovrascrivere un intero file, è necessario aprire il file (senza troncarlo) e scrivere dati non sensibili su di esso. La quantità di dati scritti deve essere uguale alla dimensione del file originale, altrimenti verrà aggiunta senza necessità. Nota che questo funziona solo supponendo che il filesystem non abbia alcun asso nella manica che porti a residui di dati in giro.

Un'implementazione C che sovrascrive un intero file con dati casuali:

void overwrite(void)
{
    struct stat sb;

    int src_fd = open("/dev/urandom", O_RDONLY);
    int dst_fd = open("file.txt", O_WRONLY);

    fstat(dst_fd, &sb);
    sendfile(dst_fd, src_fd, NULL, sb.st_size);
    fsync(dst_fd);

    close(src_fd);
    close(dst_fd);
}