Capitolo – 15
PROGRAMMAZIONE PER PULITORI DI DATI
Introduzione
Abbiamo già spiegato che quando si elimina un file da un disco, le informazioni non vengono cancellate completamente dal disco, ma vengono contrassegnate come disponibili per la scrittura di nuovi dati.
Quando formattiamo un disco, tutte le informazioni sui file e sulle directory del disco, come i record FAT e della directory root, vengono cancellate, ma l'area dati rimane invariata e nulla dell'area dati del disco viene cancellato. I dati eliminati o formattati dal sistema operativo rimangono nell'area dati così come sono e possono essere recuperati con alcuni software e interventi di recupero dati.
Pertanto, l'esigenza di eliminare completamente i dati dal disco comporta la necessità di un programma che cancelli completamente i dati dal disco. Per fare questo non basta semplicemente eliminare i file o formattare il disco: i dati presenti sul disco devono essere sovrascritti con altri dati.
I programmi utilizzati per cancellare completamente i dati da un disco sono noti come programmi di cancellazione dati. Questi programmi scrivono caratteri casuali nell'area dati per sovrascrivere i dati e cancellare tutte le informazioni precedentemente memorizzate sul disco.
Quando i dati diventano completamente irrecuperabili
Per cancellare i dati, l'area dati sul disco deve essere sovrascritta con altri dati, ma il problema non finisce qui. Per complicare ulteriormente le cose, la tendenza dei dischi magnetici a ricordare i dati sovrascritti richiede che tali dati vengano sovrascritti più volte con sequenze di dati casuali, in modo che non possano essere recuperati nemmeno con strumenti di recupero dati sofisticati.
Questo perché oggi sono disponibili tecnologie che consentono il recupero dei dati anche dopo l'utilizzo di semplici strumenti di cancellazione dati.
Alcuni prodotti per la cancellazione dei dati sovrascrivono i dati con zeri binari e uno binari. La scrittura di una serie di zeri binari e di uni binari fornisce l'effetto di riscrittura più profondo, poiché questi valori sono rispettivamente i valori magnetici minimo e massimo.
Sebbene questa sia la teoria del programma ideale per la cancellazione dei dati, in genere è sufficiente sovrascrivere i dati con un carattere ASCII casuale. Il motivo per cui affermiamo questo è che il recupero con strumenti e tecnologie sofisticati non può essere utilizzato per recuperare i dati di qualsiasi organizzazione per il recupero dati di routine, poiché queste tecnologie sono molto costose e costano milioni anche per un singolo recupero. Non solo, queste tecnologie sono disponibili solo in pochi paesi al mondo.
Parleremo solo della semplice sovrascrittura dei dati per cancellare i dati dal disco. Tuttavia, è possibile modificare ulteriormente gli stessi programmi con un minimo sforzo, in modo che scrivano solo caratteri casuali. I dati cancellati da questa idea non possono essere recuperati da nessun software di recupero dati.
Perché è così importante la cancellazione dei dati?
Quando parliamo di metodi di recupero dati, assicuriamo all'utente che i dati possono essere recuperati con alcuni interventi di recupero dati generali o speciali. Tuttavia, il recupero dei dati non è sempre una funzionalità desiderata e attesa da tutti.
Potrebbero esserci molte persone o organizzazioni sempre pronte a cancellare i dati presenti sul proprio disco in modo tale che non possano essere in alcun modo recuperati. In questi casi, il disco potrebbe contenere in precedenza dati molto sensibili che, se finissero nelle mani sbagliate, potrebbero causare danni all'organizzazione o all'utente a causa dell'uso improprio delle informazioni.
Come sappiamo, la necessità di avere sempre più spazio sul disco rigido aumenta ogni giorno. Di conseguenza, ogni anno in quasi tutte le organizzazioni le vecchie unità a bassa capacità vengono sostituite su larga scala con nuove unità ad alta capacità. Se questi vecchi dischi finissero nelle mani sbagliate, potrebbero crearsi problemi molto seri per questa organizzazione.
Secondo un articolo di cronaca pubblicato da CNET News.com il 16 gennaio 2003, gli studenti del MIT Simon Garfinkel e Abby Shelat acquistavano vecchi dischi rigidi da Internet e da altri mercatini dell'usato per scopi di ricerca, in modo da avere accesso a enormi quantità di informazioni personali che le persone non si preoccupano di cancellare.
Dopo aver acquistato 158 unità per circa 1.000 dollari, sono riusciti a raccogliere oltre 5.000 numeri di carte di credito, cartelle cliniche, informazioni finanziarie personali e aziendali dettagliate e diversi gigabyte di e-mail, codici sorgente e altre informazioni.
La coppia di studenti ha raccolto i risultati delle proprie ricerche in un rapporto intitolato "Ricordo dei dati passati: uno studio sulla sanificazione dei dischi", pubblicato nell'edizione di febbraio di IEEE Security and Privacy.
I punti principali emersi dalla ricerca sono che il mercato dell'usato dei dischi rigidi è pieno di informazioni personali, il che rende molto facile per un acquirente malintenzionato assumere l'identità di qualcun altro.
Scrittura di un programma per la cancellazione non distruttiva dei dati
Il pulitore di dati non distruttivo è un tipo di programma di cancellazione dati mediante il quale possiamo cancellare l'intero "spazio non allocato" del volume del disco, senza danneggiare in alcun modo i dati memorizzati sul disco.
L'ambito di tale data wiper è nei casi in cui si desidera cancellare tutto lo spazio non allocato del volume del disco mentre i dati allocati archiviati nel volume devono rimanere intatti. Questo tipo di programma di cancellazione dati cancella anche l'area dati dei file eliminati.
Di seguito è riportato il codice del programma per un tipo di programma di cancellazione dati non distruttivo:
///// Programma per un cancellatore di dati non distruttivo \\\\\
#include <stdio.h>
unsigned int file_num=0; /* Fornisce il numero del file
Durante la creazione automatica
di file di dati temporanei */
float status=0; /* Quanto spazio su disco è
ancora Scritto */
static char dbuf[40000]; /* Buffer dati da scrivere
File temporanei con */
char file_extension[5]=".ptt";/* Estensioni univoche per
File temporanei */
char temp[5]; /* Numero file convertito in
Corda */
char filename[40]; /* Nome file temporaneo */
vuoto principale()
{
intero senza segno i=0;
clrscr();
mentre(i<40000)
{
dbuf[i] = ' ';
io++;
}
gotoxy(10,14);cprintf(" MB ancora scritto...");
mentre(1)
{
/* Logica per creare automaticamente file temporanei con nome univoco */
strcpy(nomefile,"TTPT");
itoa(numero_file,temp,10);
strcat(nomefile,temp);
strcat(nome_file, estensione_file);
numero_file++;
write_to_temp(nomefile);
}
} //// Fine della pagina principale \\\\
///// Funzione per scrivere i dati nel file temporaneo \\\\\
write_to_temp(char *nomefile)
{
unsigned int i, conteggio=1;
galleggiante buf_status=0;
FILE *tt;
if((tt=fopen(nomefile,"wb"))==NULL)
{
fclose(tt);
printf("\n Si è verificato un errore durante la creazione del file temporaneo
file, ");
printf("\n Rimozione dei file temporanei dopo KEY BOARD
COLPO");
ottenere();
remove_temp_file();/* Rimuovi tutti i file temporanei */
}
mentre(1)
{
per(i=0;i<50;i++)
{
{NS} = ...
}
buf_status = (float)((40000*50*conteggio)/512);
stato=stato+(40000*50);
conta++;
gotossi(10,14);
cprintf("%.0f",(float)(stato/1000000));
se(kbhit())
{
fclose(tt);
printf("\n Rimozione dei file temporanei, per favore
Aspettare...");
rimuovi_file_temp();
}
se(stato_buf>=10000)
{
fclose(tt);
ritorno;
}
}
}
/* Funzione per eliminare automaticamente i file temporanei */
rimuovi_file_temp()
{
int i=0;
per(i=0;i<=numero_file;i++)
{
strcpy(nomefile,"TTPT");
questo(i,temp,10);
strcat(nomefile,temp);
strcat(nome_file, estensione_file);
rimuovi(nomefile);
}
uscita(1);
restituisci 0;
}
Commenti sulla logica e sulla codifica del programma:
In questo programma seguiamo fondamentalmente i due passaggi seguenti per cancellare lo spazio non allocato del disco:
- Crea automaticamente file di dati temporanei: prima creiamo file temporanei con nomi univoci e contenenti alcuni dati finché il volume del disco non è pieno di questi file di dati temporanei. In questo modo, tutta l'area dati non allocata dell'unità logica viene occupata dai dati dei file temporanei e tutti i dati non allocati vengono sovrascritti.
Per fare questo, ho scelto i nomi dei file temporanei nel formato TTPTxxxx.PTT, il che significa che i primi quattro caratteri dei file temporanei sono TTPT e l'estensione dei file è .PTT. Questo per fornire ai file temporanei nomi file univoci.
Ho impostato la dimensione massima del singolo file temporaneo, equivalente a circa 11.718 settori di dati, tuttavia puoi definirla a tuo piacimento. Ho scelto il carattere spazio " " (carattere ASCII 32) per riempire i dati nei file temporanei. Tuttavia, al posto dello spazio possono essere utilizzati anche caratteri casuali.
- Rimuovi tutti i file temporanei: quando l'unità logica è piena di file temporanei, indica che tutta l'area dati non allocata è stata sovrascritta. Ora tutti i file temporanei creati dal programma vengono rimossi automaticamente. E così si ottiene lo spazio non allocato cancellato.
Nella codifica del programma, l'array di caratteri filename memorizza il nome del file per generare automaticamente file temporanei con nomi diversi.
La funzione write_to_temp(filename); riempie il file temporaneo fino a 11.718 settori (poiché non si verifica alcuna occorrenza di 10.000 settori nel gruppo di scrittura specificato del buffer) di dati equivalenti con l'aiuto del buffer dati dbuf di 40.000 byte. Il buffer dati viene scritto 50 volte alla volta per velocizzare la scrittura.
I file temporanei vengono creati finché il volume del disco non è pieno e si verifica un errore di creazione file. La funzione remove_temp_file() rimuove tutti i file temporanei creati dal programma.
In questo modo tutto lo spazio non allocato viene cancellato senza danneggiare i dati del volume del disco.
Scrittura del programma per Destructive Data Wiper:
I programmi di cancellazione dati distruttivi sono quelli che scrivono direttamente sulla superficie del disco. Questo tipo di programmi di cancellazione dati funziona a un livello inferiore rispetto al file system e al sistema operativo, il che significa che tutti i dati e le altre informazioni logiche, tra cui il sistema operativo, i file system, le voci di directory e tutto ciò che è scritto sul disco, vengono cancellati.
Questi programmi di cancellazione dati cancellano direttamente i settori della superficie del disco e cancellano tutto ciò che è scritto su di esso. Poiché tutti i dati del disco, incluso il sistema operativo, vengono persi, questi programmi sono chiamati programmi di cancellazione dati distruttivi.
Questi tipi di programmi di cancellazione sono preferiti nei casi in cui l'utente desidera sovrascrivere tutto il contenuto del disco, incluso il sistema operativo e tutti i dati presenti sul disco.
Tuttavia, ci sono altri vantaggi di questo tipo di programmi di cancellazione dati. Poiché questi programmi di cancellazione dati distruttivi funzionano completamente senza OS e File system e scrivono direttamente sulla superficie del disco, sono ragionevolmente più veloci dei programmi di cancellazione dati non distruttivi.
Inoltre, se vengono creati settori logici danneggiati sul disco a causa dell'archiviazione illegale di dati casuali, anche questi settori logici danneggiati vengono completamente cancellati insieme ai dati del disco.
Di seguito è stata fornita la codifica per un programma di cancellazione dati distruttiva. Il programma è stato scritto per supportare anche dischi di grandi dimensioni. Il programma cancella i dati del secondo disco rigido fisico collegato al computer.
///// Codifica per un programma distruttivo di cancellazione dei dati \\\\\
#include<stdio.h>
#include<dos.h>
/* Struttura da utilizzare tramite la funzione getdrivegeometry mediante l'estensione INT 13H, numero funzione 0x48. */
geometria della struttura
{
unsigned int size ; /* (chiamata) dimensione del buffer */
unsigned int flags ; /* Flag informativi */
unsigned long cyl ; /* Numero di cilindri fisici su
Guidare */
unsigned long heads ;/* Numero di teste fisiche su
Guidare */
unsigned long spt ; /* Numero di settori fisici per
Traccia */
settori lunghi senza segno[2] ; /* Numero totale di
Settori su Drive */
unsigned int bps ; /* Byte per settore */
} ;
/* Struttura del formato del pacchetto di indirizzo del disco, da utilizzare dalla funzione writeabsolutesectors */
struct pacchettodischi
{
char packetsize ; /* Dimensione del pacchetto,
in genere 10H */
char riservato ; /* Riservato (0) */
int blockcount ; /* Numero di blocchi da
Trasferimento */
char far *bufferaddress ; /* indirizzo da trasferire
Respingente */
unsigned long blocknumber[2] ; /* Avvio assoluto
Numero di blocco */
} ;
///// Funzione per ottenere i parametri dell'unità \\\\\
unsigned long getdrivegeometry (int unità)
{
unione REGS i, o ;
costruire SREGS s ;
geometria della struttura g = { 26, 0, 0, 0, 0, 0, 0, 0, 0 } ;
ihah = 0x48 ; /* Funzione numero 0x48 di INT 13H
Estensioni */
ihdl = unità; /* Numero unità */
ixsi = FP_OFF ( (void far*)&g ) ;
s.ds = FP_SEG ( (void far*)&g ) ;
/* Richiama il numero di funzione specificato dell'estensione INT 13H con valori del registro di segmento */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Testa = %lu, Settori per traccia = %lu, Cilindro =
%lu\n",
g.teste,g.spt,g.cil);
/* Se la funzione Get Drive Geometry fallisce, visualizza un messaggio di errore ed esci */
se(g.spt==0)
{
printf("\n La funzione Ottieni geometria unità fallisce....");
printf("\n Estensioni non supportate, premere un tasto qualsiasi per
Uscita...");
ottenere();
uscita(1);
}
restituisci *g.sectors; /* Restituisci il numero di
Settori su Drive */
}
vuoto principale()
{
unsigned long loop=0, Settori_in_ HDD2=0;
unsigned char buffer[61440]; /* Buffer dati di 61440
byte Equivalente a
120 Settori */
unsigned long i=0;
scelta del carattere;
clrscr();
/* Se il numero totale di dischi rigidi collegati è inferiore a due, visualizza un messaggio di errore ed esci. */
se(((char)peekb(0x0040, 0x0075))<2)
{
printf("\n\n Devi avere almeno due dischi rigidi
Collegato al computer per eseguire questo");
printf("\n Programma. Questo programma è stato sviluppato
per cancellare i dati del secondo disco rigido.");
printf("\n Premi un tasto qualsiasi per uscire... ");
ottenere();
uscita(1);
}
Settori_in_HDD2 = getdrivegeometry (0x81);
printf(" Totale settori nel secondo disco rigido =
%lu\n\n",
Settori_in_HDD2);
///// Prima conferma, poi procedi \\\\\
printf("\n È un programma di cancellazione dei dati e scrive su
la superficie del disco,");
printf("\n Dopo aver eseguito questo programma, Data non può
essere recuperato da qualsiasi Software,");
printf("\n Tutti i dati nel secondo disco rigido saranno
perduto !!!");
printf("\n Premi \'Y\' per continuare, altrimenti premi un tasto qualsiasi per
Uscita... ");
scelta = getche();
interruttore(scelta)
{
caso 'y':
caso 'Y':
rottura;
predefinito:
uscita(0);
}
gotoxy(10,15);cprintf("Inizializzazione in corso, attendere...");
per(i=0;i<61440;i++)
{
buffer[i]='\0';
}
gotoxy(10,15);cprintf(" ");
gotossi(10,15);
printf("Cancellazione attuale del settore assoluto: ");
for(ciclo=0;ciclo<= Settori_in_HDD2;ciclo=ciclo+120)
{
writeabsolutesectors (0x81, ciclo, 120, buffer);
gotoxy(44,15); printf("%ld",ciclo);
se(kbhit())
{
uscita(0);
}
///// Visualizza messaggio al termine \\\\\
printf("\n\n La cancellazione dei dati è ora completata, tutti i dati in
Il secondo disco rigido è ora");
printf("\n Completamente cancellato, premi un tasto qualsiasi per uscire...");
ottenere();
}
//// Funzione per scrivere il/i settore/i assoluto/i \\\\
int writeabsolutesectors ( int unità, unsigned long sectornumber, int numofsectors, void *buffer )
{
unione REGS i, o ;
costruire SREGS s ;
struct diskaddrpacket pp ;
pp.packetsize = 16 ; /* Dimensione pacchetto = 10H */
pp.reserved = 0 ; /* Riservato = 0 */
pp.blockcount = numofsectors ;/* Numero di settori da
essere scritto */
/* per buffer dati */
pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void far*)buffer), FP_OFF((void far*)buffer));
pp.blocknumber[0] = sectornumber ; /* Numero del settore
da scrivere*/
pp.blocknumber[1] = 0 ; /* Numero blocco = 0 */
ihah = 0x43 ; /* Numero funzione */
ihal = 0x00 ; /* Scrivi Flag */
ihdl = drive ; /* Unità fisica
numero */
ixsi = FP_OFF ( (void far*)&pp ) ; /* ds:si per
buffer Parametri */
s.ds = FP_SEG ( (void far*)&pp ) ; /* ds:dire per
buffer Parametri */
/* Richiama la funzione specificata di INT 13H con i valori del registro di segmento */
int86x ( 0x13, &i, &o, &s ) ;
se (oxcflag==1)
ritorna 0 ; //fallimento
altro
ritorno 1 ; // successo
}
Commenti sulla codifica:
La geometria della struttura viene utilizzata dalla funzione getdrivegeometry mediante l'estensione INT 13H, numero funzione 0x48 per ottenere i vari parametri del disco.
La struttura diskaddrpacket è per il formato del pacchetto di indirizzi disco, da utilizzare dalla funzione writeabsolutesectors.
La funzione getdrivegeometry (int drive) serve per ottenere i parametri dell'unità del disco fisico specificato. buffer [61440] è il buffer dati di 61440 byte, equivalente a 120 settori.
(char) peekb(0x0040, 0x0075) viene utilizzato per trovare il numero di dischi rigidi collegati al computer, memorizzati nella posizione di memoria rappresentata dal segmento 0040H:offset 0075H. Se il numero totale di dischi rigidi collegati è inferiore a due, visualizza un messaggio di errore ed esci.
La funzione writeabsolutesectors (0x81, loop, 120, buffer) viene utilizzata per scrivere i dati del buffer dati su 120 settori alla volta a partire dal numero di settore assoluto specificato dal loop.
Ho scelto '\0' (carattere NULL, codice ASCII 0) per scrivere sui settori per sovrascrivere i dati. Tuttavia, puoi usare caratteri casuali per sovrascrivere i dati.
Per una descrizione dettagliata delle funzioni writeabsolutesectors e getdrivegeometry fare riferimento ai capitoli precedenti di questo libro.
Cancellazione dell'area dati di un file specifico
Abbiamo parlato dei programmi di cancellazione dati che cancellano i dati dello spazio non allocato del disco o cancellano l'intero disco. Ma se l'utente è disposto a cancellare i dati ogni volta che li elimina, potrebbe essere un processo che richiede tempo cancellare l'intero spazio non allocato del disco.
Abbiamo bisogno di questo tipo di programmi di cancellazione dati per cancellare l'area dati occupata solo da quel particolare file. Per fare questo, otteniamo l'aiuto delle voci della directory FAT e Root, per trovare l'area dati occupata da quel particolare file
Anche nel caso di floppy, se i dati non sono frammentati, possiamo farlo solo con l'aiuto delle informazioni della directory radice. La seguente tabella mostra le informazioni memorizzate da una voce della directory radice con 32 byte, per qualsiasi file:
Come vediamo nell'indice della voce della directory radice, siamo in grado di trovare il cluster iniziale e finale dei file. Il primo byte del nome file può anche contenere alcune informazioni importanti sul file. Le informazioni fornite da questo byte possono essere una delle seguenti:
Proviamo a usare queste informazioni per cancellare i dati di qualsiasi file memorizzato in un floppy disk da 1,44 Mb e 3 ½ pollici, con l'aiuto delle informazioni della directory root. Supponendo che i dati nel floppy disk non siano frammentati, il programma fornito di seguito cancella i dati del file specificato dalla sua area dati:
/* Programma per cancellare l'area dati del file specificato nel floppy disk */
#include<stdio.h>
#include<dos.h>
///// Struttura per leggere 32 byte di voce di file nella directory radice \\\\\
radice della struttura
{
unsigned char filename[8]; /* Nome file Voce di
8 byte */
unsigned char extension[3]; /* Estensione del file di
3 byte */
attributo unsigned char; /* Byte attributo file */
unsigned char reserved[10]; /* Byte riservati 10 */
unsigned int time; /* Tempo, 2 byte */
unsigned int data; /* Data, 2 byte */
unsigned int starting_cluster;/* Avvio del cluster di file,
2 byte */
unsigned long file_size; /* Dimensione file in byte,
4 byte */
};
/* Dovrebbe essere preso questo per leggere tutte le voci della directory radice */
//struct voce radice[224];
/* Struttura per leggere tutte le 16 voci di file in un settore della directory radice */
struct un_settore_radice
{
voce radice della struttura[16];
};
struct one_root_sector uno;
vuoto principale()
{
int risultato, i, num_settori, j;
char wipe_buf[512]; /* Buffer dati da utilizzare per la cancellazione
fuori dall'area dati del file */
clrscr();
result= absread(0x00, 1, 19, &one); /* Leggi il settore assoluto
19 (Primo settore della directory radice) */
se (risultato != 0)
{
perror("Errore nel settore di lettura, premere un tasto qualsiasi per
Uscita...");
ottenere();
uscita(1);
}
/* Visualizza le informazioni sui file dopo la lettura dalla directory radice */
printf(" FILE NUMERO. NOME FILE ESTENSIONE CLUSTER DI INIZIO
DIMENSIONE FILE \n\n");
per(i=1;i<16;i++)
{
printf("\n %5d %8.8s %3.3s %5u %10lu ",
io, one.entry[i].filename, one.entry[i].extension,
una. voce[i].cluster_di_avvio, una. voce[i].dimensione_file);
}
//// Ottieni l'input dell'utente per eliminare il file \\\\
printf("\n\n Inserisci il numero del file che vuoi eliminare e
Cancellare completamente ");
scanf("%d", &i);
se(i<1 || i>15)
{
printf(" \"%d\" è una scelta non valida..., premere un tasto qualsiasi
Tasto per uscire...", i);
ottenere();
uscita(1);
}
///// Prima conferma, poi continua \\\\\
printf("\n Stai per essere annientato,
Il file \"%.8s.%s\"",
una. voce[i].nomefile,
una.entrata[i].estensione);
printf("\n Vuoi continuare...(S/N) ");
switch(getche())
{
caso 'y':
caso 'Y':
rottura;
predefinito:
uscita(0);
}
///// Calcola la dimensione del file in settori \\\\\
num_settori = one.entry[i].file_size/512;
se((una. voce[i].dimensione_file%512)>0)
{
num_settori = num_settori+1;
}
/* Buffer dati di 512 byte con 512 caratteri NULL */
per(j=0;j<512;j++)
{
wipe_buf[j] = '\0';
}
///// Settore iniziale del file \\\\\
j= una. voce[i]. cluster_di_avvio+31;
/* Cancella l'area dati fino alla fine dei settori del file */
caso(j!=(one.entry[i].starting_cluster +
numero_di_settori+31) )
{
se((abswrite(0x00, 1, j, &wipe_buf))!=0)
{
printf("\n Errore durante la scrittura sui settori del disco");
Ottenere();
uscita(0);
}
j++;
}
printf("\n\n File \"%.8s.%.3s\" Eliminato !!!" ,
una. voce[i].nome_file,
una.entrata[i].estensione);
uno.entry[i].attributo = 0; /* Imposta l'attributo del file
a 0 */
una. voce[i]. tempo = 0; /* Cancella le informazioni sull'ora
archivio */
una. voce[i]. data = 0; /* Cancella le informazioni sulla data
archivio */
uno.entry[i].starting_cluster = 0; /* Imposta il cluster iniziale su 0
*/
una. voce[i]. dimensione_file = 0; /* Imposta la dimensione del file a 0 */
una.voce[i].nomefile[0]=0xE5; /* Fornisci remoto
Stato del file nel file */
///// Scrivere le informazioni di cui sopra nella directory radice \\\\\
risultato = abswrite(0x00, 1, 19, &one);
se (risultato != 0)
{
perror("Errore durante la lettura del settore, premere un tasto qualsiasi per
Uscita...");
Ottenere();
uscita(1);
}
}
Commenti sulla logica e la codifica del programma:
La struttura root viene utilizzata per leggere 32 byte di una voce di file nella directory root, mentre la struttura one_root_sector legge tutte le 16 voci di file in un settore della directory root.
Se si desidera leggere tutti i settori delle informazioni della directory radice, è necessario prenderlo come una voce struct root[224]; Tuttavia, ho scritto un programma per analizzare 16 record di un solo settore della directory radice.
Il settore iniziale del file viene calcolato come segue:
j= uno.record[i].initial_cluster+31;
Ciò avviene perché l'area dati di un floppy disk da 3 ½ pollici e 1,44 MB inizia dopo i primi 32 settori del disco. In un floppy disk della capacità specificata, un cluster corrisponde a un settore.
La tabella seguente mostra la mappa logica di un floppy disk da 3½ pollici e 1,44 MB:
Il risultato del programma viene visualizzato come segue:
Qui abbiamo eliminato e cancellato i dati del file PARTBOOT.C. Quando visualizziamo il contenuto del floppy disk tramite il comando DIR, il file PARTBOOT.C non viene visualizzato. Quando il programma viene ulteriormente eseguito, la voce per il file eliminato viene visualizzata come segue:
Qui il simbolo "" (0xE5) significa che il file è stato eliminato. (vedere la tabella per il primo carattere del nome del file).
Se si desidera scrivere lo stesso programma per il disco rigido, è necessario utilizzare anche FAT con directory root per ottenere informazioni sull'area dati di qualsiasi file.
Questo perché la velocità di frammentazione dei dati sui dischi rigidi aumenta nel tempo, man mano che i vecchi file vengono eliminati e ne vengono creati di nuovi. In questo modo non è necessario che tutti i cluster di dati di un file sul disco rimangano uno dopo l'altro in modo contiguo nell'area dati. Accedendo a FAT è possibile accedere a tutti questi cluster.
