Perché sovrascrivere un file più di una volta per eliminare in modo sicuro tutte le tracce di un file?
https://stackoverflow.com/questions/59656
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Programmi di cancellazione come Eraser consigliano di sovrascrivere i dati forse 36 volte.
A quanto ho capito, tutti i dati sono archiviati su un disco rigido come 1 o 0.
Se una volta viene eseguita una sovrascrittura di 1 e 0 casuali sull'intero file, perché non è sufficiente per rimuovere tutte le tracce del file originale?
Soluzione
Un bit del disco rigido che era uno 0, e poi viene cambiato in un "1", ha un campo magnetico leggermente più debole di quello che era un 1 e poi è stato scritto di nuovo in 1.Con apparecchiature sensibili il contenuto precedente di ciascun bit può essere individuato con un ragionevole grado di precisione, misurando le leggere variazioni di resistenza.Il risultato non sarà esattamente corretto e ci saranno degli errori, ma sarà possibile recuperare una buona parte dei contenuti precedenti.
Dopo aver scarabocchiato i pezzi 35 volte, è effettivamente impossibile discernere cosa c'era prima.
Modificare: Un'analisi moderna mostra che un singolo bit sovrascritto può essere recuperato con solo il 56% di precisione.Tentare di recuperare un intero byte è accurato solo lo 0,97% delle volte.Quindi stavo solo ripetendo una leggenda metropolitana.Potrebbe essere necessario sovrascrivere più volte quando si lavora con floppy disk o altri supporti, ma i dischi rigidi non ne hanno bisogno.
Altri suggerimenti
Daniel Feenberg (economista presso il National Bureau of Economic Research) sostiene che le possibilità che i dati sovrascritti vengano recuperati da un moderno disco rigido equivalgono a una "leggenda metropolitana":
Le agenzie di intelligence possono leggere i dati sovrascritti?
Quindi teoricamente sarebbe sufficiente sovrascrivere il file una volta con zero.
In termini convenzionali, quando viene scritto uno sul disco, il supporto registra uno, e quando viene scritto uno zero, il supporto registra uno zero.Tuttavia l'effetto reale è più vicino all'ottenimento di 0,95 quando uno zero viene sovrascritto con uno, e di 1,05 quando uno viene sovrascritto con uno.I normali circuiti del disco sono impostati in modo che entrambi questi valori vengano letti come uno, ma utilizzando circuiti specializzati è possibile capire cosa contenevano gli "strati" precedenti.Il recupero di almeno uno o due strati di dati sovrascritti non è troppo difficile da eseguire leggendo il segnale dall'elettronica della testa analogica con un oscilloscopio a campionamento digitale di alta qualità, scaricando la forma d'onda campionata su un PC e analizzandola nel software per recuperare il segnale precedentemente registrato.Ciò che fa il software è generare un segnale di lettura "ideale" e sottrarlo a ciò che è stato effettivamente letto, lasciando come differenza il resto del segnale precedente.Dato che i circuiti analogici in un disco rigido commerciale non sono affatto vicini alla qualità dei circuiti dell'oscilloscopio utilizzato per campionare il segnale, esiste la capacità di recuperare molte informazioni extra che non vengono sfruttate dall'elettronica del disco rigido (sebbene con i più recenti tecniche di codifica di canale come PRML (spiegate più avanti) che richiedono grandi quantità di elaborazione del segnale, l'uso di strumenti semplici come un oscilloscopio per recuperare direttamente i dati non è più possibile)
Immagina un settore di dati sul disco fisico.All'interno di questo settore c'è un modello magnetico (una striscia) che codifica i bit di dati memorizzati nel settore.Questo modello viene scritto da una testina di scrittura che è più o meno fissa mentre il disco ruota sotto di essa.Ora, affinché il disco rigido funzioni correttamente come dispositivo di archiviazione dati, ogni volta che una nuova striscia magnetica viene scritta in un settore, è necessario reimpostare il modello magnetico in quel settore in modo tale da poter essere leggibile in seguito.Tuttavia, non deve cancellare completamente tutte le prove del modello magnetico precedente, deve solo essere abbastanza buono (e con la quantità di correzione degli errori utilizzata oggi, abbastanza buono non deve essere poi così buono).Considerare che la testina di scrittura non seguirà sempre la stessa traiettoria del passaggio precedente su un dato settore (potrebbe essere un po' inclinata a sinistra o a destra, potrebbe passare sul settore con una leggera angolazione in un senso o nell'altro a causa alle vibrazioni, ecc.)
Ciò che ottieni è una serie di strati di schemi magnetici, con lo schema più forte corrispondente all'ultima scrittura dei dati.Con la giusta strumentazione potrebbe essere possibile leggere questa stratificazione di modelli con sufficiente dettaglio per poter determinare alcuni dei dati negli strati più vecchi.
È utile che i dati siano digitali, perché una volta estratti i dati per un dato strato è possibile determinare esattamente il modello magnetico che sarebbe stato utilizzato per scriverlo su disco e sottrarlo dalle letture (e poi farlo nel successivo strato e quello successivo).
Il motivo per cui lo vuoi è non dischi rigidi, ma SSD.Rimappano i cluster senza informarne il sistema operativo o i driver del file system.Questo viene fatto per scopi di livellamento dell'usura.Quindi, è molto probabile che il bit 0 scritto vada in una posizione diversa rispetto al bit 1 precedente.Rimuovere il controller SSD e leggere i chip flash grezzi è alla portata anche dello spionaggio aziendale.Ma con 36 sovrascritture complete del disco, il livellamento dell'usura probabilmente avrà attraversato tutti i blocchi di riserva alcune volte.
"Resanenza dei dati" C'è una serie piuttosto buona di riferimenti per quanto riguarda possibili attacchi e la loro effettiva fattibilità su Wikipedia.Ci sono anche standard e raccomandazioni DoD e NIST citati.In conclusione, è possibile, ma sta diventando sempre più difficile, recuperare i dati sovrascritti dai supporti magnetici.Tuttavia, alcuni standard (del governo statunitense) richiedono ancora almeno più sovrascritture.Nel frattempo, le parti interne del dispositivo continuano a diventare più complesse e, anche dopo la sovrascrittura, un'unità o un dispositivo a stato solido potrebbero avere copie inaspettate (si pensi alla cattiva gestione dei blocchi o al livellamento dell'usura della memoria flash (vedi Peter Gutmann).Quindi i veramente preoccupati distruggono ancora le pulsioni.
Quello che stiamo guardando qui si chiama "Remanenza dei dati". In effetti, la maggior parte delle tecnologie che sovrascrivono ripetutamente stanno (innocentemente) facendo più di ciò che è realmente necessario.Ci sono stati tentativi di recuperare dati da dischi in cui i dati erano stati sovrascritti e, con l'eccezione di alcuni casi di laboratorio, non ci sono esempi di successo di tale tecnica.
Quando parliamo di metodi di recupero, in primo luogo vedrete la microscopia a forza magnetica come la soluzione miracolosa per aggirare una sovrascrittura casuale, ma anche questa non ha registrato successi e può essere annullata in ogni caso scrivendo un buon modello di dati binari in tutta la regione su i tuoi supporti magnetici (al contrario dei semplici 0000000000).
Infine, le 36 (in realtà 35) sovrascritture a cui ti riferisci sono oggi riconosciute come datate e non più necessarie in quanto la tecnica (nota come metodo Gutmann) è stata progettata per accogliere i vari - e solitamente sconosciuti all'utente - metodi di codifica utilizzati nelle tecnologie come RLL e MFM che comunque difficilmente incontrerai.Anche le linee guida del governo statunitense affermano che la sovrascrittura è sufficiente per cancellare i dati, sebbene per scopi amministrativi non lo considerino accettabile per la "sanificazione".La ragione suggerita per questa disparità è che i settori "danneggiati" possono essere contrassegnati come danneggiati dall'hardware del disco e non sovrascritti correttamente quando arriva il momento di sovrascrivere, lasciando quindi aperta la possibilità che l'ispezione visiva del disco sia in grado di recuperarli. regioni.
Alla fine, scrivere con uno schema 1010101010101010 o abbastanza casuale è sufficiente per cancellare i dati al punto che le tecniche conosciute non possono recuperarli.
Mi sono sempre chiesto perché non venga considerata la possibilità che il file fosse stato precedentemente archiviato in una posizione fisica diversa sul disco.
Ad esempio, se si è appena verificata una deframmentazione, potrebbe facilmente esserci una copia del file facilmente recuperabile da qualche altra parte sul disco.
Ecco un'implementazione di cancellazione di Gutmann che ho messo insieme.Utilizza il generatore di numeri casuali crittografici per produrre un blocco forte di dati casuali.
public static void DeleteGutmann(string fileName)
{
var fi = new FileInfo(fileName);
if (!fi.Exists)
{
return;
}
const int GutmannPasses = 35;
var gutmanns = new byte[GutmannPasses][];
for (var i = 0; i < gutmanns.Length; i++)
{
if ((i == 14) || (i == 19) || (i == 25) || (i == 26) || (i == 27))
{
continue;
}
gutmanns[i] = new byte[fi.Length];
}
using (var rnd = new RNGCryptoServiceProvider())
{
for (var i = 0L; i < 4; i++)
{
rnd.GetBytes(gutmanns[i]);
rnd.GetBytes(gutmanns[31 + i]);
}
}
for (var i = 0L; i < fi.Length;)
{
gutmanns[4][i] = 0x55;
gutmanns[5][i] = 0xAA;
gutmanns[6][i] = 0x92;
gutmanns[7][i] = 0x49;
gutmanns[8][i] = 0x24;
gutmanns[10][i] = 0x11;
gutmanns[11][i] = 0x22;
gutmanns[12][i] = 0x33;
gutmanns[13][i] = 0x44;
gutmanns[15][i] = 0x66;
gutmanns[16][i] = 0x77;
gutmanns[17][i] = 0x88;
gutmanns[18][i] = 0x99;
gutmanns[20][i] = 0xBB;
gutmanns[21][i] = 0xCC;
gutmanns[22][i] = 0xDD;
gutmanns[23][i] = 0xEE;
gutmanns[24][i] = 0xFF;
gutmanns[28][i] = 0x6D;
gutmanns[29][i] = 0xB6;
gutmanns[30][i++] = 0xDB;
if (i >= fi.Length)
{
continue;
}
gutmanns[4][i] = 0x55;
gutmanns[5][i] = 0xAA;
gutmanns[6][i] = 0x49;
gutmanns[7][i] = 0x24;
gutmanns[8][i] = 0x92;
gutmanns[10][i] = 0x11;
gutmanns[11][i] = 0x22;
gutmanns[12][i] = 0x33;
gutmanns[13][i] = 0x44;
gutmanns[15][i] = 0x66;
gutmanns[16][i] = 0x77;
gutmanns[17][i] = 0x88;
gutmanns[18][i] = 0x99;
gutmanns[20][i] = 0xBB;
gutmanns[21][i] = 0xCC;
gutmanns[22][i] = 0xDD;
gutmanns[23][i] = 0xEE;
gutmanns[24][i] = 0xFF;
gutmanns[28][i] = 0xB6;
gutmanns[29][i] = 0xDB;
gutmanns[30][i++] = 0x6D;
if (i >= fi.Length)
{
continue;
}
gutmanns[4][i] = 0x55;
gutmanns[5][i] = 0xAA;
gutmanns[6][i] = 0x24;
gutmanns[7][i] = 0x92;
gutmanns[8][i] = 0x49;
gutmanns[10][i] = 0x11;
gutmanns[11][i] = 0x22;
gutmanns[12][i] = 0x33;
gutmanns[13][i] = 0x44;
gutmanns[15][i] = 0x66;
gutmanns[16][i] = 0x77;
gutmanns[17][i] = 0x88;
gutmanns[18][i] = 0x99;
gutmanns[20][i] = 0xBB;
gutmanns[21][i] = 0xCC;
gutmanns[22][i] = 0xDD;
gutmanns[23][i] = 0xEE;
gutmanns[24][i] = 0xFF;
gutmanns[28][i] = 0xDB;
gutmanns[29][i] = 0x6D;
gutmanns[30][i++] = 0xB6;
}
gutmanns[14] = gutmanns[4];
gutmanns[19] = gutmanns[5];
gutmanns[25] = gutmanns[6];
gutmanns[26] = gutmanns[7];
gutmanns[27] = gutmanns[8];
Stream s;
try
{
s = new FileStream(
fi.FullName,
FileMode.Open,
FileAccess.Write,
FileShare.None,
(int)fi.Length,
FileOptions.DeleteOnClose | FileOptions.RandomAccess | FileOptions.WriteThrough);
}
catch (UnauthorizedAccessException)
{
return;
}
catch (IOException)
{
return;
}
using (s)
{
if (!s.CanSeek || !s.CanWrite)
{
return;
}
for (var i = 0L; i < gutmanns.Length; i++)
{
s.Seek(0, SeekOrigin.Begin);
s.Write(gutmanns[i], 0, gutmanns[i].Length);
s.Flush();
}
}
}
Esistono applicazioni e servizi di tipo "riparazione disco" che possono ancora leggere i dati da un disco rigido anche dopo che è stato formattato, quindi sovrascrivere semplicemente con 1 e 0 casuali una volta non è sufficiente se è davvero necessario cancellare qualcosa in modo sicuro.
Direi che per l'utente medio questo è più che sufficiente, ma se ti trovi in un ambiente ad alta sicurezza (governativo, militare, ecc.) allora hai bisogno di un livello di "eliminazione" molto più alto che possa garantirlo in modo abbastanza efficace nessun dato sarà recuperabile dall'unità.
Gli Stati Uniti hanno emanato requisiti riguardanti la cancellazione di informazioni sensibili (ad es.Informazioni Top Secret) è distruggere l'unità.Fondamentalmente le unità venivano inserite in una macchina con un enorme magnete e inoltre distruggevano fisicamente l'unità per lo smaltimento.Questo perché esiste la possibilità di leggere le informazioni su un'unità, anche se vengono sovrascritte più volte.
Guarda questo: Il documento di Guttman
Basta invertire i bit in modo che gli 1 vengano scritti su tutti gli 0 e gli 0 vengano scritti su tutti gli 1, quindi azzerare tutto ciò che dovrebbe eliminare qualsiasi variabile nel campo magnetico e richiede solo 2 passaggi.
