Nous avons déjà expliqué que lorsque vous supprimez un fichier d'un disque, les informations ne sont pas complètement effacées du disque, mais sont marquées comme disponibles pour l'écriture de nouvelles données.

Lorsque nous formatons un disque, toutes les informations sur les fichiers et les répertoires du disque, tels que les enregistrements FAT et le 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 par le système d'exploitation restent telles quelles dans la zone de données 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é de supprimer complètement les données du disque entraîne la nécessité d'un programme qui efface complètement les données du disque. Pour ce faire, il ne suffit pas de simplement supprimer des fichiers ou de simplement formater le disque ; les données du disque doivent être écrasées par d’autres données.

Les programmes utilisés pour effacer complètement les données d’un disque sont appelés programmes d’effacement de données. Ces programmes écrivent des caractères aléatoires dans la zone de données pour écraser les données et effacer toutes les informations précédemment stockées sur le disque.

Lorsque les données deviennent complètement irrécupérables

Pour effacer des données, la zone de données sur le 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 disques magnétiques à mémoriser les données qui ont été écrasées nécessite que les données soient également écrasées plusieurs fois avec des séquences de données aléatoires, de sorte qu'elles ne peuvent pas être récupérées même avec des outils de récupération de données sophistiqués.

C'est parce qu'il existe aujourd'hui des technologies qui permettent de récupérer des données même après avoir utilisé quelques outils simples de suppression de données.

Certains produits d’effacement de données écrasent les données avec des zéros binaires et des uns binaires. L'écriture d'une série de zéros binaires et de uns binaires fournit l'effet de réécriture le plus profond, car ces valeurs sont respectivement les valeurs magnétiques minimales et maximales.

Bien que ce soit la théorie du programme idéal d'effacement de données, en général, l'écrasement des données avec un caractère ASCII aléatoire est suffisant. La raison pour laquelle cela est dit est que la récupération avec des outils et des technologies 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 seule récupération. De plus, ces technologies ne sont disponibles que dans quelques pays à travers le monde.

Nous discuterons uniquement de l’écrasement simple des données pour effacer les données du disque. Cependant, vous pouvez modifier davantage les mêmes programmes pour écrire uniquement des caractères aléatoires avec un peu d'effort. Les données effacées par cette idée ne peuvent pas non plus être récupérées par aucun logiciel de récupération de données.

Pourquoi la suppression des données est-elle si importante ?

Lorsque nous discutons des méthodes 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éciaux. Mais la récupération de données n’est pas toujours une fonctionnalité souhaitée et attendue par tout le monde.

Il peut y avoir de nombreuses personnes ou organisations qui sont toujours prêtes à effacer les données de leur disque de telle manière qu'elles ne puissent en aucun cas être récupérées. Dans de tels cas, le disque peut contenir auparavant des données très sensibles qui, si elles tombent entre de mauvaises mains, pourraient causer un préjudice à l'organisation ou à l'utilisateur en raison d'une mauvaise utilisation des informations.

Comme nous le savons, le besoin d’espace disque dur de plus en plus important augmente chaque jour. Par conséquent, les anciens disques de faible capacité sont remplacés à grande échelle chaque année par de nouveaux disques de grande capacité dans presque toutes les organisations. Si ces vieux disques tombent entre de mauvaises mains, cela pourrait créer un problème très sérieux pour cette organisation.

Selon un article publié par CNET News.com le 16 janvier 2003, les étudiants du MIT Simon Garfinkel et Abby Shelat achetaient de vieux disques durs à des fins de recherche sur Internet et d'autres ventes de disques durs d'occasion pour avoir accès à de vastes quantités d'informations personnelles que les gens ne prennent pas la peine de supprimer.

Après avoir acheté 158 clés USB pour environ 1 000 dollars américains, ils ont réussi à collecter plus de 5 000 numéros de cartes de crédit, des dossiers médicaux, des informations financières personnelles et professionnelles détaillées et plusieurs gigaoctets d'e-mails, de codes sources et d'autres informations.

Ces deux étudiants ont compilé leurs conclusions 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é d’occasion des disques durs est rempli d’informations personnelles, ce qui permet à un acheteur malveillant d’usurper très facilement l’identité de quelqu’un d’autre.

Programme d'écriture pour l'effacement non destructif des données

L'effaceur de données non destructif est une sorte de programme d'effacement de données à l'aide duquel nous pouvons effacer l'intégralité de « 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.

Le champ d'application d'un tel programme d'effacement de données est dans les cas où vous souhaitez effacer tout l'espace non alloué du volume de disque alors que les données allouées stockées dans le volume doivent rester intactes. Ce type de programme d'effacement de données efface également la zone de données des fichiers supprimés.

Le codage du programme pour un type de programme d'effacement de données non destructif a été donné ci-après :

///// Programme pour un effacement de données non destructif \\\\\

    #include <stdio.h>
  unsigned int file_num=0; /* Fournit le numéro de fichier
  Pendant la création automatique
  des fichiers de données temporaires */
  float status=0; /* Quelle est la quantité d'espace disque disponible
  toujours écrit */
  static char dbuf[40000]; /* Tampon de données à écrire
  Fichiers temporaires avec */
  char file_extension[5]=".ptt";/* Extensions uniques pour
  Fichiers temporaires */
  char temp[5]; /* Numéro de fichier converti en
  Chaîne */
  char filename[40]; /* Nom du fichier temporaire */
  void main()
  {
  int non signé i=0;
  clrscr();
  tant que(i<40000)
  {
  dbuf[i] = ' ';
  je++;
  }
  gotoxy(10,14);cprintf(" MB toujours écrit... ");
  pendant que(1)
  {

/* Logique pour créer automatiquement des fichiers temporaires avec un nom unique */

    strcpy(nom de fichier,"TTPT");
  itoa(numéro_fichier,temp,10);
  strcat(nom de fichier,temp);
  strcat(nom_fichier,extension_fichier);
  fichier_num++;
  write_to_temp(nom de fichier);
  }
  } //// Fin du \\\\ principal

///// Fonction pour écrire les données dans un fichier temporaire \\\\\

    write_to_temp(char *nom_fichier)
  {
  int non signé i, nombre=1;
  flotteur buf_status=0;
  FICHIER *tt;
  si((tt=fopen(nom de fichier,"wb"))==NULL)
  {
  fclose(tt);
  printf("\n Une erreur s'est produite lors de la création temporaire
  déposer, ");
  printf("\n Suppression des fichiers temporaires après KEY BOARD
  FRAPPER");
  obtenir();
  remove_temp_file();/* Supprimer tous les fichiers temporaires */
  }
  pendant que(1)
  {
  pour(i=0;i<50;i++)
  {
  fprintf(tt,"%s",dbuf);
  }
  buf_status = (float)((40000*50*count)/512);
  statut=statut+(40000*50);
  compter++;
  gotoxy(10,14);
  cprintf("%.0f",(float)(état/1000000));
  si(kbhit())
  {
  fclose(tt);
  printf("\n Suppression des fichiers temporaires, s'il vous plaît
  Attendez...");
  supprimer_fichier_temp();
  }
  si(buf_status>=10000)
  {
  fclose(tt);
  retour;
  }
  }
  }

/* Fonction pour supprimer automatiquement les fichiers temporaires */

    supprimer_fichier_temp()
  {
  int i=0;
  pour(i=0;i<=numéro_fichier;i++)
  {
  strcpy(nom de fichier,"TTPT");
  ceci(i,temp,10);
  strcat(nom de fichier,temp);
  strcat(nom_fichier,extension_fichier);
  supprimer(nom de fichier);
  }
  sortie(1);
  retourner 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 rempli de ces fichiers de données temporaires. En procédant ainsi, toute la zone de données non allouée 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 que l'extension des fichiers est .PTT. Cela a pour but de 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 vos besoins. J'ai choisi le caractère espace « » (caractère ASCII 32) pour remplir les données dans les 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 signifie que toute la zone de données non allouée est désormais écrasée. Désormais, tous les fichiers temporaires créés par le programme sont automatiquement supprimés. L'espace non alloué est ainsi supprimé.

Dans le codage du programme, le tableau de caractères filename 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 le groupe d'écriture spécifié du tampon) de données équivalentes à l'aide du tampon de données dbuf de 40 000 octets. Le tampon de données est écrit 50 fois à 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 façon, tout l’espace non alloué est effacé sans endommager les données du volume du disque.

Programme d'écriture pour Destructive Data Wiper :

Les programmes de suppression de données destructeurs sont ceux qui écrivent directement sur la surface du disque. Ce type de programme de suppression de données fonctionne à un niveau inférieur à celui du système de fichiers et du 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, les entrées 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 est écrit dessus. 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 les cas où l'utilisateur souhaite écraser tout ce qui se trouve sur le disque, y compris le système d'exploitation et toutes les données du disque.

Cependant, ce type de programme d'effacement de données présente d'autres avantages. Comme ces programmes d'effacement de données destructifs fonctionnent complètement indépendamment du système d'exploitation et du système de fichiers et écrivent directement sur la surface du disque, ils sont raisonnablement plus rapides que les programmes d'effacement de données non destructifs.

De plus, si des secteurs logiques défectueux sont créés sur le disque en raison du stockage illégal de 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 de suppression de données destructeur a été donné ci-après. Le programme a été écrit pour prendre en charge également les disques de grande taille. Le programme efface les données du deuxième disque dur physique connecté à l'ordinateur.

///// Codage pour un programme destructeur d'effacement de données \\\\\

    #include<stdio.h>
  #include<dos.h>

/* Structure à utiliser par la fonction getdrivegeometry utilisant l'extension INT 13H, numéro de fonction 0x48. */

    structure géométrique
  {
  unsigned int size ; /* (appel) taille du tampon */
  drapeaux int non signés ; /* Drapeaux d'information */
  unsigned long cyl ; /* Nombre de cylindres physiques sur
  Conduire */
  têtes longues non signées ;/* Nombre de têtes physiques sur
  Conduire */
  unsigned long spt ; /* Nombre de secteurs physiques par
  Piste */
  secteurs unsigned long[2] ; /* Nombre total de
  Secteurs sur Drive */
  unsigned int bps ; /* Octets par secteur */
  } ;

/* Structure du format du paquet d'adresse de disque, à utiliser par la fonction writeabsolutesectors */

    structure diskadderpacket
  {
  char packetsize ; /* Taille du paquet,
  généralement 10H */
  char réservé ; /* Réservé (0) */
  int blockcount ; /* Nombre de blocs à
  Transfert */
  char far *bufferaddress ; /* adresse à transférer
  Tampon */
  unsigned long blocknumber[2] ; /* Démarrage absolu
  Numéro de bloc */
  } ;

///// Fonction pour obtenir les paramètres du lecteur \\\\\

    unsigned long getdrivegeometry (int lecteur)
  {
  syndicat REGS i, o ;
  structure SREGS s ;
  structure géométrie g = { 26, 0, 0, 0, 0, 0, 0, 0 } ;
  ihah = 0x48 ; /* Fonction numéro 0x48 de INT 13H
  Rallonges */
  ihdl = lecteur; /* Numéro de lecteur */
  ixsi = FP_OFF ( (void far*)&g ) ;
  s.ds = FP_SEG ( (void far*)&g ) ;

/* Invoquer le numéro de fonction spécifié de l'extension INT 13H avec les valeurs du registre de segment */

    int86x ( 0x13, &i, &o, &s ) ;
  printf("\n Tête = %lu, Secteurs par piste = %lu, Cylindre =
  %lu\n",
  g.têtes,g.spt,g.cyl);

/* Si la fonction d'obtention de géométrie du lecteur échoue, afficher un message d'erreur et quitter */

    si(g.spt==0)
  {
  printf("\n La fonction Obtenir la géométrie du lecteur échoue....");
  printf("\n Extensions non prises en charge, appuyez sur n'importe quelle touche pour
  Sortie...");
  obtenir();
  sortie(1);
  }
  retourner *g.sectors; /* Renvoyer le nombre de
  Secteurs sur Drive */
  }
  void main()
  {
  boucle unsigned long=0, Secteurs_dans_HDD2=0 ;
  unsigned char buffer[61440]; /* Tampon de données de 61440
  octets équivalent à
  120 secteurs */
  non signé long i=0;
  choix de char;
  clrscr();

/* Si le nombre total de disques durs connectés est inférieur à deux, affichez un message d'erreur et quittez. */

    si(((char)peekb(0x0040, 0x0075))<2)
  {
  printf("\n\n Vous devez avoir au moins deux disques durs
  Connecté à votre ordinateur pour exécuter ceci » );
  printf("\n Programme. Ce programme a été développé
  pour effacer les données du deuxième disque dur.");
  printf("\n Appuyez sur n'importe quelle touche pour quitter... ");
  obtenir();
  sortie(1);
  }
  Secteurs_dans_HDD2 = getdrivegeometry (0x81);
  printf(" Nombre total de secteurs sur le deuxième disque dur =
  %lu\n\n",
  Secteurs_dans_HDD2);

///// Confirmez d'abord, puis continuez \\\\\

    printf("\n C'est un programme d'effacement de données, et il écrit sur
  la surface du disque,");
  printf("\n Après avoir exécuté ce programme, les données ne peuvent pas
  être récupéré par n'importe quel logiciel,");
  printf("\n Toutes les données du deuxième disque dur seront
  perdu !!!");
  printf("\n Appuyez sur \'Y\' pour continuer, sinon appuyez sur n'importe quelle touche pour
  Sortie... ");
  choix = getche();
  commutateur (choix)
  {
  cas 'y':
  cas 'Y':
  casser;
  défaut:
  sortie(0);
  }
  gotoxy(10,15);cprintf(" Initialisation, veuillez patienter...");
  pour(i=0;i<61440;i++)
  {
  tampon[i]='\0';
  }
  gotoxy(10,15);cprintf(" ");
  gotoxy(10,15);
  printf("Effacement actuel du secteur absolu : ");
  for(loop=0;loop<= Secteurs_dans_HDD2;loop=loop+120)
  {
  writeabsolutesectors (0x81, boucle, 120, tampon) ;
  gotoxy(44,15); printf("%ld",boucle);
  si(kbhit())
  {
  sortie(0);
  }

///// Afficher un message une fois terminé \\\\\

    printf("\n\n L'effacement des données est maintenant terminé, toutes les données dans
  Le deuxième disque dur est maintenant »);
  printf("\n Complètement effacé, appuyez sur n'importe quelle touche pour quitter...");
  obtenir();
  }

//// Fonction pour écrire des secteurs absolus \\\\

    int writeabsolutesectors ( int lecteur, unsigned long numérodesecteur, int nombredesecteurs, void *buffer )
  {
  syndicat REGS i, o ;
  structure SREGS s ;
  struct diskaddrpacket pp ;
  pp.packetsize = 16 ; /* Taille du paquet = 10H */
  pp.reserved = 0 ; /* Réservé = 0 */
  pp.blockcount = numofsectors ;/* Nombre de secteurs à
  être écrit */

/* pour le tampon de données */

    pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void far*)tampon), FP_OFF((void far*)tampon));
  pp.blocknumber[0] = sectornumber ; /* Numéro de secteur
  à écrire*/
  pp.blocknumber[1] = 0 ; /* Numéro de bloc = 0 */
  ihah = 0x43 ; /* Numéro de fonction */
  ihal = 0x00 ; /* Drapeaux d'écriture */
  ihdl = lecteur ; /* Lecteur physique
  nombre */
  ixsi = FP_OFF ( (void far*)&pp ) ; /* ds:si pour
  Paramètres du tampon */
  s.ds = FP_SEG ( (void far*)&pp ) ; /* ds:dire pour
  Paramètres du tampon */

/* Invoquer la fonction spécifiée de INT 13H avec des valeurs de registre de segment */

    int86x ( 0x13, &i, &o, &s ) ;
  si ( oxcflag==1)
  retour 0 ; //échec
  autre
  retour 1 ; // succès
  }

Commentaires sur le codage :

La géométrie de la structure est utilisée par la fonction getdrivegeometry utilisant l'extension INT 13H, numéro de fonction 0x48 pour obtenir les différents paramètres du disque.

La structure diskaddrpacket est destinée au format de paquet d'adresse de disque, à utiliser par la fonction writeabsolutesectors.

La fonction getdrivegeometry (int drive) permet d'obtenir les paramètres du lecteur du disque physique spécifié numéro de lecteur drive. 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és à 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.

La fonction 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 loop.

J'ai choisi '\0' (caractère NULL, code ASCII 0) pour écrire sur les secteurs afin d'é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 plus haut dans ce livre.

Effacement de la zone de données d'un fichier spécifique

Nous avons discuté des programmes d'effacement de 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 souhaite effacer les données à chaque fois qu'il les supprime, l'effacement de l'intégralité de l'espace non alloué du disque peut prendre du temps.

Nous avons besoin de ce type de programme d'effacement de données pour effacer la zone de données occupée uniquement par ce fichier particulier. Pour ce faire, nous nous appuyons sur les entrées du répertoire FAT et du répertoire racine, pour trouver la zone de données occupée par ces fichiers particuliers

Même dans le cas d'une 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 du répertoire racine de 32 octets, pour n'importe quel fichier :

entrée du répertoire racine

Comme nous le voyons dans la table des matières de l'entrée du répertoire racine, nous sommes capables de trouver le groupe 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 suivantes :

Premier fichier de caractères

Essayons d'utiliser ces informations pour effacer les données de tout fichier stocké sur une disquette de 1,44 Mo et de 3 ½ pouces, à l'aide des informations du répertoire racine. En supposant que les données de la disquette ne soient pas fragmentées, le programme donné ci-après 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 \\\\\

    structure racine
  {
  unsigned char filename[8]; /* Nom de fichier Entrée de
  8 octets */
  unsigned char extension[3]; /* Extension du fichier de
  3 octets */
  attribut char non signé ; /* Octet d'attribut de fichier */
  unsigned char reserved[10]; /* Octets réservés 10 */
  unsigned int heure; /* Heure, 2 octets */
  unsigned int date; /* Date, 2 octets */
  unsigned int starting_cluster;/* Cluster de démarrage du fichier,
  2 octets */
  unsigned long file_size; /* Taille du fichier en octets,
  4 octets */
  };

/* Cela devrait être pris pour lire toutes les entrées du répertoire racine */

//entrée racine de la structure[224];

/* Structure pour lire les 16 entrées de fichier dans un secteur du répertoire racine */

      structure one_root_sector
    {
    entrée racine de structure[16];
    };
    struct one_root_sector un;
    void main()
    {
    int résultat, i, num_sectors,j;
    char wipe_buf[512]; /* Tampon de données à utiliser pour effacer
    sortir la zone de données du fichier */
    clrscr();
    résultat = absread(0x00, 1, 19, &one); /* Lire le secteur absolu
    19 (Premier secteur du répertoire racine) */
    si (résultat != 0)
    {
    perror("Erreur lors de la lecture du secteur, appuyez sur n'importe quelle touche pour
    Sortie...");
    obtenir();
    sortie(1);
    }

/* Afficher les informations des fichiers après la lecture à partir du répertoire racine */

      printf(" FICHIER N° NOM DE FICHIER EXTENSION CLUSTER DE DÉPART
    TAILLE DU FICHIER \n\n");
    pour(i=1;i<16;i++)
    {
    printf("\n %5d %8.8s %3.3s %5u %10lu ",
    i, one.entry[i].nom de fichier, one.entry[i].extension,
    one.entry[i].starting_cluster, one.entry[i].file_size);
    }

//// Obtenir la saisie de l'utilisateur pour supprimer le fichier \\\\

      printf("\n\n Entrez le numéro du fichier que vous souhaitez supprimer et
    Essuyer complètement ");
    scanf("%d", &i);
    si(i<1 || i>15)
    {
    printf(" \"%d\" est un choix non valide..., Appuyez sur n'importe quelle touche
    Clé pour sortir...", i);
    obtenir();
    sortie(1);
    }

///// Confirmez d'abord, puis continuez \\\\\\

      printf("\n Vous êtes sur le point d'être anéanti,
    Le fichier \"%.8s.%s\"",
    une.entrée[i].nom de fichier,
    une.entrée[i].extension);
    printf("\n Voulez-vous continuer...(O/N) ");
    commutateur(getche())
    {
    cas 'y':
    cas 'Y':
    casser;
    défaut:
    sortie(0);
    }

///// Calculer la taille du fichier en secteurs \\\\\

      num_sectors = une.entrée[i].file_size/512;
    si((one.entry[i].file_size%512)>0)
    {
    num_secteurs = num_secteurs+1;
    }

/* Tampon de données de 512 octets avec 512 caractères NULL */

      pour(j=0;j<512;j++)
    {
    wipe_buf[j] = '\0';
    }

///// Secteur de départ du fichier \\\\\

      j= une.entrée[i].starting_cluster+31;

/* Effacer la zone de données jusqu'à la fin des secteurs du fichier */

      après(j!=(one.entry[i].starting_cluster +
    nombre_de_secteurs+31) )
    {
    si((abswrite(0x00, 1, j, &wipe_buf))!=0)
    {
    printf("\n Erreur lors de l'écriture dans les secteurs du disque");
    obtenir();
    sortie(0);
    }
    j++;
    }
    printf("\n\n Fichier \"%.8s.%.3s\" Supprimé !!!" ,
    une.entrée[i].nom_fichier,
    une.entrée[i].extension);
    une.entrée[i].attribute = 0; /* Définir l'attribut du fichier
    à 0 */
    une.entrée[i].heure = 0; /* Effacer les informations de temps
    déposer */
    une.entrée[i].date = 0; /* Effacer les informations de date
    déposer */
    un.entrée[i].starting_cluster = 0; /* Définir le cluster initial à 0
    */
    une.entrée[i].file_size = 0; /* Définir la taille du fichier à 0 */
    une.entrée[i].nom_fichier[0]=0xE5; /* Donner la télécommande
    Statut du fichier dans le fichier */

///// Écrivez les informations ci-dessus dans le répertoire racine \\\\\\

      résultat = abswrite(0x00, 1, 19, &one);
    si (résultat != 0)
    {
    perror("Erreur de lecture du secteur, appuyez sur n'importe quelle touche pour
    Sortie...");
    obtenir();
    sortie(1);
    }
    }

Commentaires sur la logique et le codage du programme :

La structure racine est utilisée pour lire 32 octets d'une 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 souhaitez lire tous les secteurs des informations du répertoire racine, vous devez les prendre comme une entrée struct root[224] ; Cependant, j'ai écrit un programme pour analyser 16 enregistrements d'un seul secteur du répertoire racine.

Le secteur de départ du fichier est calculé comme suit :

j= un.enregistrement[i].initial_cluster+31;

Cela est dû au fait que la zone de données d'une disquette de 1,44 Mo et 3 ½ pouces commence après les 32 premiers secteurs du disque. Et dans une disquette de la capacité spécifiée, un cluster correspond à un secteur.

Le tableau suivant montre la carte logique d'une disquette de 1,44 Mo et 3½ pouces :

disquette

Le résultat du programme est affiché comme suit :

Numéro de dossier

Ici, nous avons supprimé et effacé les données du fichier PARTBOOT.C. Lorsque nous regardons le contenu de la disquette à l'aide de la commande DIR, le fichier PARTBOOT.C n'y apparaît pas. Lorsque le programme est exécuté plus loin, l'entrée du fichier supprimé s'affiche comme suit :

partie d'un bateau

Ici, le symbole «  » (0xE5) signifie que le fichier a été supprimé. (voir tableau pour le premier caractère du nom de fichier).

Si vous souhaitez écrire le même programme pour le disque dur, vous devez également utiliser FAT avec le répertoire racine pour obtenir les informations sur la zone de données de n'importe quel fichier.

Cela est dû au fait que le taux de fragmentation des données sur les disques durs augmente au fil du temps à mesure que les anciens fichiers sont supprimés et que de nouveaux sont créés. Il n’est alors pas nécessaire que tous les clusters de données d’un fichier sur le disque restent les uns après les autres de manière contiguë dans la zone de données. En accédant à FAT, vous pouvez accéder à tous ces clusters.

Récupération de données avec et sans programmation

Auteur : Tarun Tyagi

← Chapitre précédent

Chapitre suivant →