Chapitre – 15
Programmation pour les effaceurs de données
Présentation
Nous avons déjà discuté de cela lorsque nous supprimons un fichier du disque, les informations ne sont pas complètement effacées du lecteur mais elles sont marquées comme disponibles pour que de nouvelles données soient écrites dessus.
Lorsque nous formatons un lecteur, toutes les informations des fichiers et des répertoires du lecteur tels que les FAT et les entrées du répertoire racine sont effacées, mais la zone de données reste inchangée et rien de la zone de données du disque n'est effacé. Les données supprimées ou formatées à l'aide du système d'exploitation restent dans la zone de données telles quelles et peuvent être récupérées avec certains efforts de récupération de données et un logiciel de récupération de données.
Par conséquent, la nécessité d'éliminer complètement les données d'un lecteur entraîne l'exigence d'un tel programme qui efface complètement les données du disque. Pour ce faire, il ne suffit pas de simplement supprimer les fichiers ou simplement de formater le lecteur, mais les données sur le disque doivent être écrasées par d'autres données.
Les programmes utilisés pour effacer complètement les données du disque sont appelés programmes d'effacement des données. Ces programmes écrivent des caractères aléatoires sur la zone de données pour écraser les données et effacer toutes les informations précédemment enregistrées sur le disque.
Lorsque les données deviennent complètement irrécupérables
Pour effacer les données, la zone de données du disque doit être écrasée par d'autres données, mais le problème ne s'arrête pas là. Pour compliquer encore les choses, la tendance des lecteurs magnétiques à se souvenir des données qui ont été écrasées nécessite que les données soient également écrasées plusieurs fois par des séquences aléatoires de données afin qu'elles ne puissent pas être récupérées même avec des outils de récupération de données sophistiqués
Il en est ainsi parce que les technologies qui peuvent récupérer des données même après l'utilisation de quelques effaceurs de données simples sont disponibles aujourd'hui.
Certains produits d'effacement de données écrasent les zéros binaires et les uns binaires sur les données. L'écriture d'une série de zéros binaires et de uns binaires produit l'effet d'écrasement le plus profond car ces valeurs sont respectivement les valeurs magnétiques minimale et maximale.
Bien que ce soit la théorie d'un programme d'effacement de données idéal, mais généralement, les données sur l'écriture par caractère ASCII aléatoire sont suffisantes. La raison en est que la récupération par des outils et une technologie de récupération sophistiqués ne peut pas être utilisée pour récupérer les données d'une organisation pour une récupération de données de routine, car ces technologies sont très coûteuses et coûtent des millions, même pour une récupération unique. Non seulement cela, mais aussi ces technologies ne sont disponibles que dans quelques pays du monde.
Nous ne discuterons que du simple écrasement des données pour effacer les données du disque. Cependant, vous pouvez modifier davantage les mêmes programmes pour écrire les caractères aléatoires uniquement avec quelques petits efforts. Les données effacées par cette idée ne peuvent pas non plus être récupérées par un logiciel de récupération de données.
Pourquoi l'effacement des données est si important
Lorsque nous discutons des techniques de récupération de données, nous assurons à l'utilisateur que les données peuvent être récupérées avec des efforts de récupération de données généraux ou spécifiques. Mais la récupération de données n'est pas toujours une fonctionnalité souhaitée et attendue pour tout le monde.
Il peut y avoir beaucoup de personnes ou d'organisations qui sont toujours disposées à effacer les données de leur disque de manière à ce qu'elles ne puissent être récupérées par aucun moyen. Dans de tels cas, des données très sensibles peuvent être précédemment stockées sur le disque, qui, si elles tombent entre de mauvaises mains, peuvent nuire à l'organisation ou à l'utilisateur en utilisant à mauvais escient les informations.
Comme nous savons que l'exigence de plus en plus d'espace sur les disques durs augmente de jour en jour. En conséquence, les anciens disques de petite capacité sont remplacés par de nouveaux disques de grande capacité à grande échelle chaque année dans presque toutes les organisations. Si ces disques plus anciens tombent entre de mauvaises mains, cela peut créer un problème très sérieux pour cette organisation.
Selon des informations publiées par CNET News.com, le 16 janvier 2003, les étudiants du Massachusetts Institute of Technology Simon Garfinkel et Abbi Shelat ont acheté de vieux disques durs, au nom de la recherche, sur le Web et d'autres objets d'occasion. ventes pour découvrir les énormes quantités d'informations personnelles que les gens ne prennent pas la peine d'effacer.
Après avoir acheté 158 disques pour environ 1 000 USD, ils ont réussi à collecter plus de 5 000 numéros de carte de crédit, des dossiers médicaux, des informations financières personnelles et d'entreprise détaillées, ainsi que plusieurs gigaoctets d'e-mails, de codes sources et d'autres informations.
Ces deux étudiants ont compilé leurs découvertes dans un rapport intitulé "Remembrance of Data Passed: A Study of Disk Sanitation" publié dans l'édition de février de IEEE Security and Privacy.
Les principaux points qui ressortent de l'étude sont que le marché de l'occasion pour les disques durs regorge d'informations personnelles, ce qui permet très facilement à un acheteur malveillant d'usurper l'identité de quelqu'un d'autre.
Programme d'écriture pour un effaceur de données non destructif
L'effaceur de données non destructif est une sorte de programme d'effacement de données à l'aide duquel nous pouvons effacer tout l'"espace non alloué" ; du volume du disque, sans endommager les données stockées sur le disque, de quelque manière que ce soit.
La portée d'un tel effaceur de données est dans les cas où vous souhaitez effacer tout l'espace non alloué du volume de disque tandis que les données allouées stockées dans le volume doivent rester intactes. Ce type de programme d'effacement des données efface également la zone de données des fichiers supprimés.
Le programme codant pour un type de non – programme destructeur d'effacement des données a été donné ensuite :
///// Programme pour un effaceur de données non destructif \\\\\
#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)
{
/* Logique pour créer automatiquement des fichiers temporaires avec un nom unique */
strcpy(filename,"TTPT");
itoa(file_num,temp,10);
strcat(filename,temp);
strcat(filename,file_extension);
file_num++;
write_to_temp(filename);
}
} //// End of Main \\\\
///// Fonction pour écrire les données dans le fichier temporaire \\\\\
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;
}
}
}
/* Fonction pour supprimer automatiquement les fichiers temporaires */
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;
}
Commentaires sur la logique et le codage du programme :
Dans ce programme, nous suivons essentiellement les deux étapes suivantes pour effacer l'espace non alloué du disque :
- Créer automatiquement des fichiers de données temporaires : nous créons d'abord des fichiers temporaires avec des noms uniques et contenant des données jusqu'à ce que le volume du disque soit plein avec ces fichiers de données temporaires. Ce faisant, toute la zone de données non allouées du lecteur logique est occupée par les données des fichiers temporaires et toutes les données non allouées sont écrasées.
Pour ce faire, j'ai choisi les noms des fichiers temporaires au format TTPTxxxx.PTT, ce qui signifie que les quatre premiers caractères des fichiers temporaires sont TTPT et l'extension des fichiers est .PTT. Il est fait pour fournir aux fichiers temporaires des noms de fichiers uniques.
J'ai défini la taille maximale du fichier temporaire unique, équivalente à environ 11 718 secteurs de données, mais vous pouvez la définir selon vous. J'ai choisi le caractère espace “ " (caractère ASCII 32) pour remplir les données des fichiers temporaires. Cependant, des caractères aléatoires peuvent également être utilisés à la place de l'espace.
- Supprimer tous les fichiers temporaires : lorsque le lecteur logique est plein de fichiers temporaires, cela indique que toute la zone de données non allouée est maintenant écrasée. Désormais, tous les fichiers temporaires créés par le programme sont supprimés automatiquement. Et ainsi effacé l'espace non alloué est atteint.
Dans le codage du programme, le nom de fichier du tableau de caractères stocke le nom du fichier pour générer automatiquement des fichiers temporaires, avec des noms différents.
La fonction write_to_temp(filename); remplit le fichier temporaire jusqu'à 11 718 secteurs (car il n'y a pas d'occurrence de 10 000 secteurs dans l'écriture de groupe spécifiée du tampon) données équivalentes à l'aide du tampon de données dbuf de 40 000 octets. 50 fois le tampon de données est écrit à la fois pour accélérer l'écriture.
Les fichiers temporaires sont créés jusqu'à ce que le volume du disque soit plein et qu'une erreur de création de fichier se produise. La fonction remove_temp_file() supprime tous les fichiers temporaires créés par le programme.
De cette manière, tout l'espace non alloué est effacé sans endommager les données du volume de disque.
Programme d'écriture pour Destructive Data Wiper :
Les programmes d'effacement de données destructifs sont ceux qui écrivent directement sur la surface du disque. Ce type de programmes d'effacement de données fonctionne à un niveau inférieur au système de fichiers et au système d'exploitation, ce qui signifie que toutes les données et autres informations logiques, y compris le système d'exploitation, les systèmes de fichiers, l'entrée de répertoire et tout ce qui est écrit sur le disque, sont effacées.
Ces programmes d'effacement de données effacent directement les secteurs de la surface du disque et effacent tout ce qui y est écrit. Comme toutes les données du disque, y compris le système d'exploitation, sont perdues, ces programmes sont appelés programmes d'effacement de données destructeurs.
Ces types de programmes d'effacement sont préférés dans de tels cas, où l'utilisateur est prêt à tout écraser sur le disque, y compris le système d'exploitation et toutes les données sur le disque.
Cependant, ce type de programme d'effacement des données présente d'autres avantages. Comme ces programmes d'effacement de données destructeurs fonctionnent complètement sans système d'exploitation ni système de fichiers et écrivent directement sur la surface du disque, ils sont raisonnablement plus rapides que les effaceurs de données non destructifs.
De plus, si des secteurs logiques défectueux sur le disque sont créés en raison du stockage illégal de certaines données aléatoires, ces secteurs logiques défectueux sont également complètement effacés avec les données du disque.
Le codage d'un programme d'effacement de données destructeur a été donné ensuite. Le programme a également été écrit pour prendre en charge les disques de grande taille. Le programme efface les données du deuxième disque dur physique connecté à l'ordinateur.
///// Codage pour un programme d'effacement de données destructeur \\\\\
#include<stdio.h>
#include<dos.h>
/* Structure à utiliser par la fonction getdrivegeometry à l'aide de l'extension INT 13H, numéro de fonction 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 */
} ;
/* Structure du format de paquet d'adresse de disque, à utiliser par la fonction 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 */
} ;
///// Fonction pour obtenir les paramètres du lecteur \\\\\
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 ) ;
/* Invoque le numéro de fonction spécifié de l'extension INT 13H avec les valeurs de registre de segment */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Head = %lu, Sectors Per Track = %lu, Cylinder =
%lu\n",
g.heads,g.spt,g.cyl);
/* Si la fonction d'obtention de la géométrie du lecteur échoue, affichez le message d'erreur et quittez */
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();
/* Si nombre total de disques durs connectés est inférieur à deux Afficher un message d'erreur et quitter. */
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);
///// Confirmez d'abord, puis continuez \\\\\
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);
}
///// Afficher le message une fois terminé \\\\\
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();
}
//// Fonction d'écriture de secteur(s) absolu(s) \\\\
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 */
/* pour le tampon de données */
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 */
/* Invoque la fonction spécifiée de INT 13H avec des valeurs de registre de segment */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; //failure
else
return 1 ; // success
}
Commentaires sur le codage :
La géométrie de la structure est utilisée par la fonction getdrivegeometry à l'aide de l'extension INT 13H, numéro de fonction 0x48 pour obtenir les différents paramètres du disque.
La structure diskaddrpacket correspond au format de paquet d'adresse de disque, à utiliser par la fonction writeabsolutesectors.
La fonction getdrivegeometry (lecteur int) consiste à obtenir les paramètres de lecteur du lecteur numéro de lecteur physique spécifié sur le disque. buffer [61440] est le tampon de données de 61440 octets, équivalent à 120 secteurs.
(char) peekb(0x0040, 0x0075) est utilisé pour trouver le nombre de disques durs connectés à l'ordinateur, stocké à l'emplacement mémoire représenté par le segment 0040H:offset 0075H. Si le nombre total de disques durs connectés est inférieur à deux, affichez un message d'erreur et quittez.
writeabsolutesectors ( 0x81, loop, 120, buffer ) est utilisée pour écrire les données du tampon de données sur 120 secteurs à la fois à partir du numéro de secteur absolu spécifié par la boucle.
J'ai choisi ‘\0’ (caractère NULL, code ASCII 0) à écrire sur les secteurs pour écraser les données. Cependant, vous pouvez utiliser des caractères aléatoires pour écraser les données.
Pour une description détaillée des fonctions writeabsolutesectors et getdrivegeometry, reportez-vous aux chapitres donnés précédemment dans ce livre.
Effacer la zone de données d'un fichier spécifique
Nous avons discuté des programmes d'effacement des données qui effacent les données de l'espace non alloué du disque ou effacent l'intégralité du disque. Mais si l'utilisateur est prêt à effacer les données à chaque fois qu'il supprime les données, cela peut prendre du temps d'effacer tout l'espace non alloué du disque.
Nous avons besoin de ce type de programmes d'effacement de données pour effacer la zone de données uniquement occupée par ce fichier particulier. Pour ce faire, nous obtenons l'aide des entrées de répertoire FAT et Root, pour trouver la zone de données occupée par ces fichiers particuliers
Même en cas de disquette, si les données ne sont pas fragmentées, nous ne pouvons le faire qu'à l'aide des informations du répertoire racine. Le tableau suivant montre les informations stockées par une entrée de répertoire racine de 32 octets, pour n'importe quel fichier :
Comme nous le voyons dans la table des matières de l'entrée du répertoire racine, nous sommes capables de trouver le cluster de début et de fin des fichiers. Le premier octet du nom de fichier peut également contenir des informations importantes sur le fichier. Les informations fournies par cet octet peuvent être l'une des données ci-dessous :
Essayons ces informations pour effacer les données de n'importe quel fichier stocké en 1.44Mb, 3 ½ pouces disquette, à l'aide des informations du répertoire racine. En supposant que les données de la disquette ne sont pas fragmentées, le programme indiqué ensuite efface les données du fichier spécifié de sa zone de données :
/* Programme pour effacer la zone de données du fichier spécifié sur la disquette */
#include<stdio.h>
#include<dos.h>
///// Structure pour lire 32 octets d'entrée de fichier dans le répertoire racine \\\\\
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 */
};
/* Doit être utilisé pour lire toutes les entrées du répertoire racine */
//struct root entry[224] ;
/* Structure pour lire les 16 entrées de fichier dans un secteur du répertoire racine */
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);
}
/* Afficher les informations des fichiers après lecture à partir du répertoire racine */
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);
}
//// Obtenir l'entrée de l'utilisateur pour supprimer le fichier \\\\
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);
}
///// Confirmez d'abord, puis continuez \\\\\\
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);
}
///// Calculer la taille du fichier dans les secteurs \\\\\
num_sectors = one.entry[i].file_size/512;
if((one.entry[i].file_size%512)>0)
{
num_sectors = num_sectors+1;
}
/* Tampon de données de 512 octets avec 512 caractères NULL */
for(j=0;j<512;j++)
{
wipe_buf[j] = '\0';
}
///// Secteur de départ du fichier \\\\\
j= one.entry[i].starting_cluster+31;
/* Effacer la zone de données jusqu'à la fin des secteurs du fichier */
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 */
///// Écrivez les informations ci-dessus dans le répertoire racine \\\\\\
result= abswrite(0x00, 1, 19, &one);
if (result != 0)
{
perror("Error in Reading Sector, Press any key to
Exit...");
getch();
exit(1);
}
}
Commentaires sur la logique et le codage du programme :
La racine de la structure est utilisée pour lire 32 octets d'entrée de fichier dans le répertoire racine et la structure one_root_sector lit les 16 entrées de fichier dans un secteur du répertoire racine
Si vous voulez lire tous les secteurs d'informations du répertoire racine, vous devez le prendre comme struct root entry[224] ; cependant j'ai écrit le programme pour analyser les 16 entrées d'un seul secteur du répertoire racine.
Le secteur de départ du fichier a été calculé comme suit :
j= un.entry[i].starting_cluster+31 ;
Il en est ainsi parce que la zone de données de 1,44 Mo, 3 ½ pouce disquette démarre après les 32 premiers secteurs de la disquette. Et dans la disquette de capacité spécifiée, un cluster est d'un secteur.
Le tableau suivant montre la carte logique de 1.44MB, 3½ disquette en pouces :
La sortie du programme est affichée comme suit :
Ici, nous avons supprimé et effacé les données du fichier PARTBOOT.C. Lorsque nous voyons le contenu de la disquette avec la commande DIR, le fichier PARTBOOT.C n'y est pas affiché. Lorsque nous exécutons davantage le programme, l'entrée du fichier supprimé s'affiche comme suit :
Ici, le caractère “ ” (0xE5), indique que le fichier a été supprimé. (voir le tableau pour le premier caractère du nom de fichier).
Si vous voulez écrire le même programme pour le disque dur, vous devez également utiliser le FAT avec le répertoire racine pour obtenir les informations de la zone de données de n'importe quel fichier.
Il en est ainsi parce que le taux de données fragmentées dans les disques durs augmente avec le temps à mesure que les anciens fichiers sont supprimés et que de nouveaux fichiers sont créés. Il n'est alors pas nécessaire que tous les clusters de données de n'importe quel fichier du lecteur restent l'un après l'autre en continu dans la zone de données. En accédant à FAT, vous pouvez accéder à tous ces clusters.
Page modifiée le: 09/03/2022
Maison