Capitolo – 15
Programmazione per Data Wiper
Introduzione
Ne abbiamo già discusso quando eliminiamo qualsiasi file dal disco, le informazioni non vengono cancellate completamente dall'unità ma vengono contrassegnate come disponibili per la scrittura di nuovi dati su di essa.
Quando formattiamo un'unità, tutte le informazioni di file e directory dell'unità come FAT e voci di directory radice vengono cancellate, ma l'area dati rimane invariata e nulla dall'area dati del disco viene cancellato. I dati che vengono eliminati o formattati utilizzando il sistema operativo rimangono nell'area dati così com'è e possono essere recuperati con alcuni sforzi di recupero dati e software di recupero dati.
Pertanto, la necessità di eliminare completamente i dati da un'unità determina la necessità di un programma di questo tipo che cancelli completamente i dati dal disco. Per fare ciò non è sufficiente cancellare i file o semplicemente formattare il drive ma i dati sul disco devono essere sovrascritti da qualche altro dato.
I programmi utilizzati per cancellare completamente i dati dal disco sono noti come programmi di cancellazione dei dati. Questi programmi scrivono caratteri casuali nell'area dati per sovrascrivere i dati e cancellare tutte le informazioni precedentemente salvate sul disco.
Quando i dati diventano completamente irrecuperabili
Per cancellare i dati, l'area dati del disco dovrebbe essere sovrascritta da alcuni altri dati su di esso ma il problema non finisce qui. A complicare ulteriormente le cose, la tendenza delle unità magnetiche a ricordare i dati che sono stati sovrascritti richiede che anche i dati vengano sovrascritti più volte da sequenze casuali di dati in modo che non possano essere recuperati nemmeno con sofisticati strumenti di recupero dati
È così perché oggi sono disponibili le tecnologie in grado di recuperare i dati anche dopo l'utilizzo di alcuni semplici tergicristalli.
Alcuni prodotti per la cancellazione dei dati eseguono la sovrascrittura di zeri binari e quelli binari sui dati. Scrivendo una serie di zeri binari e uno binari si ottiene l'effetto di sovrascrittura più profondo poiché questi valori sono rispettivamente i valori magnetici minimo e massimo.
Sebbene questa sia la teoria di un programma ideale per cancellare i dati, ma in generale, la sovrascrittura dei dati con un carattere ASCII casuale è sufficiente. Il motivo per affermarlo è che il ripristino mediante sofisticati strumenti e tecnologie di ripristino non può essere utilizzato per recuperare i dati di alcuna organizzazione per un ripristino di routine dei dati perché queste tecnologie sono molto costose e costano milioni anche per un singolo ripristino. Non solo questo, ma anche queste tecnologie sono disponibili solo in pochi paesi nel mondo.
Discuteremo solo della semplice sovrascrittura dei dati per cancellare i dati dal disco. Tuttavia è possibile modificare ulteriormente gli stessi programmi per scrivere i caratteri casuali solo con qualche piccolo sforzo. Anche i dati cancellati da questa idea non possono essere recuperati da nessun software di recupero dati.
Perché la cancellazione dei dati è così importante
Quando discutiamo delle tecniche di recupero dei dati, assicuriamo all'utente che i dati possono essere recuperati con alcuni sforzi di recupero dati generali o specifici. Ma il recupero dei dati non è sempre una funzionalità desiderata e prevista per tutti.
Potrebbero esserci molte persone o organizzazioni che sono sempre disposte a cancellare i dati del proprio disco in modo tale che non debbano essere recuperati in alcun modo. In questi casi è possibile che dati molto sensibili siano stati precedentemente archiviati sul disco e, se finiti in mani sbagliate, potrebbero danneggiare l'organizzazione o l'utente a causa di un uso improprio delle informazioni.
Come sappiamo, la richiesta di sempre più spazio sui dischi rigidi aumenta di giorno in giorno. Di conseguenza, le vecchie unità di piccola capacità vengono sostituite da nuovi dischi di grande capacità su larga scala ogni anno in quasi tutte le organizzazioni. Se questi vecchi dischi vengono presi da mani sbagliate, potrebbe creare un problema molto serio per quell'organizzazione.
Secondo le notizie pubblicate da CNET News.com, il 16 gennaio 2003, gli studenti del Massachusetts Institute of Technology Simon Garfinkel e Abbi Shelat hanno acquistato vecchi dischi rigidi, in nome della ricerca, dal Web e altri di seconda mano vendite per scoprire l'enorme quantità di informazioni personali che le persone non si preoccupano di cancellare.
Dopo aver acquistato 158 unità per circa 1000 dollari, sono riusciti a raccogliere oltre 5000 numeri di carta di credito, cartelle cliniche, informazioni finanziarie dettagliate personali e aziendali e diversi gigabyte di e-mail, codici sorgente e altre informazioni.
La coppia di questi studenti ha raccolto i risultati in un rapporto intitolato "Remembrance of Data Passed: A Study of Disk Sanitation" 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 che rendono molto facile per un acquirente malintenzionato assumere l'identità di qualcun altro.
Programma di scrittura per la pulizia dei dati non distruttiva
Il wiper dei dati non distruttivo è una sorta di programma di cancellazione dei dati tramite il quale possiamo cancellare l'intero “spazio non allocato” del volume del disco, senza danneggiare in alcun modo i dati archiviati nel disco.
L'ambito di tale pulizia dei dati è nei casi in cui si desidera cancellare tutto lo spazio non allocato del volume del disco mentre i dati allocati archiviati nel volume dovrebbero rimanere intatti. Questo tipo di programma di cancellazione dei dati cancella anche l'area dati dei file eliminati.
La codifica del programma per un tipo di non – il programma di cancellazione dei dati distruttivi è stato fornito di seguito:
///// Programma per un wipe non distruttivo dei dati \\\\\
#include <stdio.h>
unsigned int file_num=0; /* Provides File Number
During the Auto Creation
of Temporary Data files */
float status=0; /* How Much Disk space is
still Written */
static char dbuf[40000]; /* Data Buffer to write
Temporary Files with */
char file_extension[5]=".ptt";/* Unique Extensions for
Temporary Files */
char temp[5]; /* File Number converted to
String */
char filename[40]; /* Temporary File name */
void main()
{
unsigned int i=0;
clrscr();
while(i<40000)
{
dbuf[i] = ' ';
i++;
}
gotoxy(10,14);cprintf(" MB Still Written...");
while(1)
{
/* Logica per creare automaticamente file temporanei con nome univoco */
strcpy(filename,"TTPT");
itoa(file_num,temp,10);
strcat(filename,temp);
strcat(filename,file_extension);
file_num++;
write_to_temp(filename);
}
} //// End of Main \\\\
///// Funzione per scrivere i dati nel file temporaneo \\\\\
write_to_temp(char *filename)
{
unsigned int i, count=1;
float buf_status=0;
FILE *tt;
if((tt=fopen(filename,"wb"))==NULL)
{
fclose(tt);
printf("\n Error occurred while creating temporary
file, ");
printf("\n Removing temporery Files After KEY BOARD
HIT");
getch();
remove_temp_file();/* Remove All temporary files */
}
while(1)
{
for(i=0;i<50;i++)
{
fprintf(tt,"%s",dbuf);
}
buf_status = (float)((40000*50*count)/512);
status= status+(40000*50);
count++;
gotoxy(10,14);
cprintf("%.0f",(float)(status/1000000));
if(kbhit())
{
fclose(tt);
printf("\n Removing Temporery Files, Please
Wait...");
remove_temp_file();
}
if(buf_status>=10000)
{
fclose(tt);
return;
}
}
}
/* Funzione per eliminare automaticamente i file temporanei */
remove_temp_file()
{
int i=0;
for(i=0;i<=file_num;i++)
{
strcpy(filename,"TTPT");
itoa(i,temp,10);
strcat(filename,temp);
strcat(filename,file_extension);
remove(filename);
}
exit(1);
return 0;
}
Commenti sulla logica e la codifica del programma:
In questo programma fondamentalmente seguiamo i due passaggi seguenti per cancellare lo spazio non allocato del disco:
- Crea automaticamente file di dati temporanei: per prima cosa creiamo file temporanei con nomi univoci e contenenti alcuni dati fino a quando 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 ciò, 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 viene fatto per fornire ai file temporanei i nomi di file univoci.
Ho impostato la dimensione massima del singolo file temporaneo, pari a circa 11.718 settori di dati tuttavia puoi definirla secondo te. Ho scelto il carattere spazio “ ” (carattere ASCII 32) per inserire i dati in 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 nomefile memorizza il nome del file per generare automaticamente file temporanei, con nomi diversi.
La funzione write_to_temp(nomefile); riempie il file temporaneo fino a 11.718 settori (perché non si verificano 10.000 settori nella scrittura di gruppo specificata del buffer) dati equivalenti con l'aiuto del buffer di dati dbuf di 40.000 byte. Viene scritto 50 volte il buffer di dati 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 del 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.
Programma di scrittura per Destructive Data Wiper:
I programmi di cancellazione dei dati distruttivi sono quelli che scrivono direttamente sulla superficie del disco. Questo tipo di programmi di cancellazione dei dati funziona a un livello inferiore rispetto al file system e al sistema operativo, il che significa che tutti i dati e altre informazioni logiche, inclusi OS, file system, voci di directory e tutto ciò che è scritto sul disco, vengono cancellati.
Questi programmi di cancellazione dei 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 vengono chiamati programmi di cancellazione dei dati distruttivi.
Questi tipi di programmi di pulizia sono preferiti in questi casi, in cui l'utente è disposto a sovrascrivere tutto sul disco, incluso il sistema operativo e tutti i dati sul disco.
Tuttavia ci sono alcuni vantaggi in più di questo tipo di programmi di cancellazione dei dati. Poiché questi programmi di cancellazione dei dati distruttivi funzionano completamente senza OS e file system e scrivono direttamente sulla superficie del disco, sono ragionevolmente più veloci dei pulitori di dati non distruttivi.
Inoltre, se vengono creati settori danneggiati logici sul disco a causa della memorizzazione illegale di alcuni dati casuali, anche questi settori danneggiati logici vengono completamente cancellati con i dati del disco.
In seguito è stata fornita la codifica per un programma di cancellazione dei dati distruttivi. 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 che deve essere utilizzata dalla funzione getdrivegeometry utilizzando l'estensione INT 13H, numero funzione 0x48. */
struct geometry
{
unsigned int size ; /* (call) size of Buffer */
unsigned int flags ; /* Information Flags */
unsigned long cyl ; /* Number of Physical Cylinders on
Drive */
unsigned long heads ;/* Number of Physical Heads on
Drive */
unsigned long spt ; /* Number of Physical Sectors Per
Track */
unsigned long sectors[2] ; /* Total Number of
Sectors on Drive */
unsigned int bps ; /* Bytes Per Sector */
} ;
/* Struttura del formato del pacchetto Disk Address, da utilizzare con la funzione writeabsolutesectors */
struct diskaddrpacket
{
char packetsize ; /* Size of Packet,
generally 10H */
char reserved ; /* Reserved (0) */
int blockcount ; /* Number of Blocks to
Transfer */
char far *bufferaddress ; /* address to Transfer
Buffer */
unsigned long blocknumber[2] ; /* Starting Absolute
Block Number */
} ;
///// Funzione per ottenere i parametri dell'unità \\\\\
unsigned long getdrivegeometry (int drive)
{
union REGS i, o ;
struct SREGS s ;
struct geometry g = { 26, 0, 0, 0, 0, 0, 0, 0 } ;
i.h.ah = 0x48 ; /* Function Number 0x48 of INT 13H
Extensions */
i.h.dl = drive; /* Drive Number */
i.x.si = FP_OFF ( (void far*)&g ) ;
s.ds = FP_SEG ( (void far*)&g ) ;
/* Richiama il numero di funzione specificato dell'interno INT 13H con valori del registro di segmento */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Head = %lu, Sectors Per Track = %lu, Cylinder =
%lu\n",
g.heads,g.spt,g.cyl);
/* Se la funzione Get Drive Geometry non riesce, visualizza un messaggio di errore ed esci */
if(g.spt==0)
{
printf("\n Get Drive Geometry Function Fails....");
printf("\n Extensions Not Supported, Press any Key to
Exit...");
getch();
exit(1);
}
return *g.sectors; /* Return The Number of
Sectors on Drive */
}
void main()
{
unsigned long loop=0, Sectors_in_ HDD2=0;
unsigned char buffer[61440]; /* Data buffer of 61440
bytes Equivalent to
120 Sectors */
unsigned long i=0;
char choice;
clrscr();
/* Se il totale n. di dischi rigidi collegati è inferiore a due Visualizza messaggio di errore ed Esci. */
if(((char)peekb(0x0040, 0x0075))<2)
{
printf("\n\n You Must Have At least Two Hard Disks
Attached to your Computer To Run This");
printf("\n Program. This Program has been developed
to Wipe the Data of Second Hard Disk.");
printf("\n Press any Key to Exit... ");
getch();
exit(1);
}
Sectors_in_HDD2 = getdrivegeometry (0x81);
printf(" Total Sectors in Second Hard Disk =
%lu\n\n",
Sectors_in_HDD2);
///// Prima conferma, poi procedi \\\\\
printf("\n It is A Data Wiping Program, and Writes on
the Surface of the Disk,");
printf("\n After running this program, Data can not
be recovered by any Software,");
printf("\n All The Data in Second Hard Disk will be
lost !!!");
printf("\n Press \'Y\' to Continue, Else any key to
Exit... ");
choice = getche();
switch(choice)
{
case 'y':
case 'Y':
break;
default:
exit(0);
}
gotoxy(10,15);cprintf(" Initializing, Please Wait...");
for(i=0;i<61440;i++)
{
buffer[i]='\0';
}
gotoxy(10,15);cprintf(" ");
gotoxy(10,15);
printf("Currently Wiping Absolute Sector: ");
for(loop=0;loop<= Sectors_in_HDD2;loop=loop+120)
{
writeabsolutesectors (0x81, loop, 120, buffer);
gotoxy(44,15); printf("%ld",loop);
if(kbhit())
{
exit(0);
}
///// Visualizza messaggio al termine \\\\\
printf("\n\n Data wiping is Now Completed, All the Data in
Second Hard Disk is now");
printf("\n Completely Erased, Press any Key to Exit...");
getch();
}
//// Funzione per scrivere i settori assoluti \\\\
int writeabsolutesectors ( int drive, unsigned long sectornumber, int numofsectors, void *buffer )
{
union REGS i, o ;
struct SREGS s ;
struct diskaddrpacket pp ;
pp.packetsize = 16 ; /* Packet Size = 10H */
pp.reserved = 0 ; /* Reserved = 0 */
pp.blockcount = numofsectors ;/* Number of Sectors to
be written */
/* per Buffer dati */
pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void far*)buffer), FP_OFF((void far*)buffer));
pp.blocknumber[0] = sectornumber ; /* Sector number
to be written*/
pp.blocknumber[1] = 0 ; /* Block number = 0 */
i.h.ah = 0x43 ; /* Function Number */
i.h.al = 0x00 ; /* Write Flags */
i.h.dl = drive ; /* Physical Drive
number */
i.x.si = FP_OFF ( (void far*)&pp ) ; /* ds:si for
buffer Parameters */
s.ds = FP_SEG ( (void far*)&pp ) ; /* ds:si for
buffer Parameters */
/* Richiama la funzione specificata di INT 13H con valori di registro di segmento */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; //failure
else
return 1 ; // success
}
Commenti sulla codifica:
La geometria della struttura viene utilizzata dalla funzione getdrivegeometry che utilizza INT 13H Extension, Function Number 0x48 per ottenere i vari parametri del disco.
La struttura diskaddrpacket è per il formato del pacchetto Disk Address, da utilizzare con la funzione writeabsolutesectors.
La funzione getdrivegeometry (int drive) serve per ottenere i parametri dell'unità dell'unità fisica del numero di unità specificata dal disco. buffer [61440] è il buffer di dati di 61440 byte, equivalente a 120 settori.
(char) peekb(0x0040, 0x0075) viene utilizzato per trovare il numero di dischi rigidi collegati al computer, archiviati nella posizione di memoria rappresentata dal segmento 0040H:offset 0075H. Se il numero totale di dischi rigidi collegati è inferiore a due Visualizza messaggio di errore ed esci.
La funzione writeabsolutesectors ( 0x81, loop, 120, buffer ) viene utilizzata per scrivere i dati del buffer di dati su 120 settori alla volta a partire dal numero di settore assoluto specificato dal loop.
Ho scelto ‘\0’ (carattere NULL, codice ASCII 0) da 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 forniti in precedenza in questo libro.
Cancellazione dell'area dati di un file specifico
Abbiamo discusso dei programmi di cancellazione dei dati che cancellano i dati dallo spazio non allocato del disco o cancellano l'intero disco. Ma se l'utente è disposto a cancellare i dati ogni volta che elimina i dati, potrebbe essere necessario del tempo per cancellare l'intero spazio non allocato del disco.
Abbiamo bisogno di questo tipo di programmi di cancellazione dei dati per cancellare l'area dati occupata solo da quel particolare file. Per fare ciò, otteniamo l'aiuto dalle voci della directory FAT e Root, per trovare l'area dati occupata da quel particolare file
Anche in caso di floppy, se i dati non sono frammentati, possiamo farlo solo con l'aiuto delle informazioni della directory principale. La tabella seguente mostra le informazioni memorizzate da una voce della directory principale con 32 byte, per qualsiasi file:
Come vediamo nel sommario della voce della directory principale, siamo in grado di trovare il cluster iniziale e finale dei file. Il primo Byte del nome del file può anche contenere alcune informazioni importanti sul file. Le informazioni fornite da questo byte possono essere una delle seguenti:
Proviamo queste informazioni per cancellare i dati di qualsiasi file archiviato in 1.44Mb, 3 ½ floppy disk da pollici, con l'aiuto delle informazioni sulla directory principale. Supponendo che i dati nel floppy disk non siano frammentati, il programma indicato successivamente 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 File Entry nella directory principale \\\\\
struct root
{
unsigned char filename[8]; /* File name Entry of
8 Bytes */
unsigned char extension[3]; /* Extension of File of
3 Bytes */
unsigned char attribute; /* File Attribute Byte */
unsigned char reserved[10]; /* Reserved Bytes 10 */
unsigned int time; /* Time, 2 Bytes */
unsigned int date; /* Date, 2 Bytes */
unsigned int starting_cluster;/* Starting Cluster of File,
2 Bytes */
unsigned long file_size; /* File Size in Bytes,
4 Bytes */
};
/* Dovrebbe essere preso per leggere tutte le voci della directory principale */
//struct voce radice[224];
/* Struttura per leggere tutte le 16 voci di file in un settore della directory principale */
struct one_root_sector
{
struct root entry[16];
};
struct one_root_sector one;
void main()
{
int result, i, num_sectors,j;
char wipe_buf[512]; /* Data Buffer to be used to wipe
out the data Area of file */
clrscr();
result= absread(0x00, 1, 19, &one); /* Read Absolute Sector
19 (First Sector of Root Directory) */
if (result != 0)
{
perror("Error in Reading Sector, Press any key to
Exit...");
getch();
exit(1);
}
/* Visualizza le informazioni sui file dopo la lettura dalla directory principale */
printf(" FILE NO. FILENAME EXTENSION STARTING CLUSTER
FILESIZE \n\n");
for(i=1;i<16;i++)
{
printf("\n %5d %8.8s %3.3s %5u %10lu ",
i, one.entry[i].filename, one.entry[i].extension,
one.entry[i].starting_cluster, one.entry[i].file_size);
}
//// Ottieni input utente per eliminare il file \\\\
printf("\n\n Enter The File Number, you Want to Delete and
Wipe out Completely ");
scanf("%d", &i);
if(i<1 || i>15)
{
printf(" \"%d\" is an Invalid Choice..., Press any
Key to Exit...", i);
getch();
exit(1);
}
///// Prima conferma, poi continua \\\\\\
printf("\n You are About to wipe-out,
The File \"%.8s.%s\"",
one.entry[i].filename,
one.entry[i].extension);
printf("\n Do you Want to Continue...(Y/N) ");
switch(getche())
{
case 'y':
case 'Y':
break;
default:
exit(0);
}
///// Calcola la dimensione del file nei settori \\\\\
num_sectors = one.entry[i].file_size/512;
if((one.entry[i].file_size%512)>0)
{
num_sectors = num_sectors+1;
}
/* Buffer dati di 512 byte con 512 caratteri NULL */
for(j=0;j<512;j++)
{
wipe_buf[j] = '\0';
}
///// Settore iniziale del file \\\\\
j= one.entry[i].starting_cluster+31;
/* Cancella i dati Area Fino alla Fine dei Settori del file */
while(j!=(one.entry[i].starting_cluster +
num_sectors+31) )
{
if((abswrite(0x00, 1, j, &wipe_buf))!=0)
{
printf("\n Error Writing on Disk Sectors");
getch();
exit(0);
}
j++;
}
printf("\n\n File \"%.8s.%.3s\" Deleted !!!" ,
one.entry[i].filename,
one.entry[i].extension);
one.entry[i].attribute = 0; /* Set the File Attribute
to 0 */
one.entry[i].time = 0; /* Wipe The Time information
of File */
one.entry[i].date = 0; /* Wipe The Date information
of File */
one.entry[i].starting_cluster = 0; /* Set the Starting cluster to 0
*/
one.entry[i].file_size = 0; /* Set the file Size to 0 */
one.entry[i].filename[0]=0xE5; /* Give the Deleted
file Status to the File */
///// Scrivi le informazioni sopra nella directory principale \\\\\\
result= abswrite(0x00, 1, 19, &one);
if (result != 0)
{
perror("Error in Reading Sector, Press any key to
Exit...");
getch();
exit(1);
}
}
Commenti su logica e codifica del programma:
La struttura root viene utilizzata per leggere 32 byte di File Entry nella directory principale e la struttura one_root_sector legge tutte le 16 voci di file in un settore della directory principale
Se vuoi leggere tutti i settori delle informazioni della directory root dovresti prenderlo come struct root entry[224]; tuttavia ho scritto il programma per analizzare le 16 voci di un solo settore della directory principale.
Il Settore di Partenza del File è stato calcolato come segue:
j= one.entry[i].starting_cluster+31;
Lo fa perché l'area dati di 1.44 MB, 3 ½ il floppy disk in pollici inizia dopo i primi 32 settori del floppy disk. E nel floppy disk con capacità specificata, un cluster è di un settore.
La tabella seguente mostra la mappa logica di 1,44 MB, 3½ floppy disk in pollici:
L'output del programma viene visualizzato come segue:
Qui abbiamo cancellato e cancellato i dati del file PARTBOOT.C. Quando vediamo il contenuto del floppy con il comando DIR, il file PARTBOOT.C non viene visualizzato lì. Quando eseguiamo ulteriormente il programma, la voce del file eliminato viene mostrata come segue:
Qui, il personaggio “ ” (0xE5), rappresenta che il file è stato eliminato. (vedi la tabella per il primo carattere del nome del file).
Se si desidera scrivere lo stesso programma per l'hard disk, è necessario utilizzare anche la FAT con la directory principale per ottenere le informazioni dell'area dati di qualsiasi file.
È così perché la percentuale di dati frammentati nelle unità disco rigido aumenta con il tempo man mano che i file più vecchi vengono eliminati e vengono creati nuovi file. Quindi non è necessario che tutti i cluster di dati di qualsiasi file nell'unità rimangano uno dopo l'altro continuamente nell'area dati. Accedendo a FAT, puoi accedere a tutti quei cluster.
Pagina modificata il: 10/03/2022
Casa