Hoofdstuk – 15
Programmering voor gegevenswissers
Invoering
We hebben dat al besproken wanneer we een bestand van de schijf verwijderen, de informatie wordt niet volledig van de schijf gewist, maar wordt gemarkeerd als beschikbaar voor nieuwe gegevens die erover kunnen worden geschreven.
Als we een schijf formatteren, wordt alle informatie van bestanden en mappen van de schijf, zoals FAT's en Root Directory Entries, gewist, maar het gegevensgebied blijft ongewijzigd en niets van het gegevensgebied van de schijf wordt gewist. De gegevens die zijn verwijderd of geformatteerd met behulp van het besturingssysteem, blijven in het gegevensgebied zoals het is en kunnen worden hersteld met enkele inspanningen voor gegevensherstel en software voor gegevensherstel.
Daarom leidt de noodzaak om gegevens volledig van een schijf te verwijderen ertoe dat er een dergelijk programma nodig is dat de gegevens volledig van de schijf wist. Hiervoor is het niet voldoende om alleen de bestanden te verwijderen of alleen de schijf te formatteren, maar de gegevens op de schijf moeten worden overschreven door andere gegevens.
De programma's die worden gebruikt om de gegevens volledig van de schijf te wissen, staan bekend als de programma's voor het wissen van gegevens. Deze programma's schrijven willekeurige tekens op het gegevensgebied om gegevens te overschrijven en alle informatie die eerder op de schijf was opgeslagen, te wissen.
Wanneer de gegevens volledig onherstelbaar worden
Om de gegevens te wissen, moet het gegevensgebied van de schijf worden overschreven door andere gegevens erop, maar hier houdt het probleem niet op. Om de zaken nog ingewikkelder te maken, vereist de neiging van magnetische schijven om gegevens te onthouden die zijn overschreven, dat gegevens ook meerdere keren worden overschreven door willekeurige reeksen gegevens, zodat ze niet kunnen worden hersteld, zelfs niet met geavanceerde hulpprogramma's voor gegevensherstel
Het is zo omdat de technologieën die gegevens kunnen herstellen, zelfs na het gebruik van enkele eenvoudige gegevenswissers, tegenwoordig beschikbaar zijn.
Sommige producten voor het wissen van gegevens voeren binaire nullen en binaire enen uit over gegevens. Door een reeks binaire nullen en binaire enen te schrijven, wordt het diepste overschrijfeffect bereikt, aangezien deze waarden respectievelijk de minimale en maximale magnetische waarden zijn.
Hoewel dit de theorie is van een ideaal programma voor het wissen van gegevens, is over het algemeen het overschrijven van gegevens met een willekeurig ASCII-teken voldoende. De reden om dit te zeggen is dat het herstel door geavanceerde hersteltools en -technologie niet kan worden gebruikt om de gegevens van een organisatie te herstellen voor een routinematig gegevensherstel, omdat deze technologieën erg duur zijn en miljoenen kosten, zelfs voor enkelvoudig herstel. Niet alleen dit, maar ook deze technologieën zijn slechts in enkele landen over de hele wereld beschikbaar.
We zullen alleen het eenvoudige overschrijven van gegevens bespreken om de gegevens van de schijf te wissen. U kunt echter dezelfde programma's verder aanpassen om de willekeurige karakters te schrijven met slechts een paar kleine inspanningen. Gegevens die door dit idee zijn weggevaagd, kunnen ook niet worden hersteld door software voor gegevensherstel.
Waarom het wissen van gegevens zo belangrijk is
Als we het hebben over de technieken voor gegevensherstel, verzekeren we de gebruiker dat de gegevens kunnen worden hersteld met enkele algemene of specifieke inspanningen voor gegevensherstel. Maar gegevensherstel is niet altijd een gewenste en verwachte functie voor iedereen.
Er kunnen veel mensen of organisaties zijn die altijd bereid zijn om de gegevens van hun schijf op zo'n manier te wissen dat ze op geen enkele manier hersteld zouden moeten worden. In dergelijke gevallen kunnen zeer gevoelige gegevens eerder op de schijf zijn opgeslagen, wat de organisatie of gebruiker kan schaden door de informatie te misbruiken.
Zoals we weten, neemt de behoefte aan meer en meer ruimte op harde schijven met de dag toe. Als gevolg hiervan worden de oudere schijven met een kleine capaciteit elk jaar in bijna elke organisatie op grote schaal vervangen door nieuwe schijven met een grote capaciteit. Als deze oudere schijven in verkeerde handen komen, kan dit een zeer ernstig probleem opleveren voor die organisatie.
Volgens nieuws gepubliceerd door CNET News.com hebben op 16 januari 2003 de studenten van het Massachusetts Institute of Technology, Simon Garfinkel en Abbi Shelat, oude harde schijven gekocht, in naam van onderzoek, van het web en andere tweedehands verkopen om de enorme hoeveelheden persoonlijke informatie bloot te leggen die mensen niet willen wissen.
Na 158 schijven te hebben gekocht voor ongeveer $ 1000, slaagden ze erin meer dan 5000 creditcardnummers, medische dossiers, gedetailleerde persoonlijke en zakelijke financiële informatie en enkele gigabytes aan e-mails, broncodes en andere informatie te verzamelen.
Het tweetal van deze studenten heeft hun bevindingen gebundeld in een rapport met de titel "Remembrance of Data Passed: A Study of Disk Sanitation" gepubliceerd in de februari-editie van IEEE Security and Privacy.
De belangrijkste punten die uit het onderzoek naar voren zijn gekomen, zijn dat de tweedehandsmarkt voor harde schijven gevuld is met persoonlijke informatie, waardoor het voor een kwaadwillende koper heel gemakkelijk is om de identiteit van iemand anders aan te nemen.
Programma schrijven voor niet-destructieve gegevenswisser
De niet-destructieve gegevenswisser is een soort programma voor het wissen van gegevens waarmee we de volledige “niet-toegewezen ruimte” kunnen wissen. van het schijfvolume, zonder de gegevens die op de schijf zijn opgeslagen, op enigerlei wijze te schaden.
De reikwijdte van een dergelijke gegevenswisser is in de gevallen waarin u alle niet-toegewezen ruimte van het schijfvolume wilt wissen, terwijl de toegewezen gegevens die op het volume zijn opgeslagen onaangeroerd moeten blijven. Dit type programma voor het wissen van gegevens wist ook het gegevensgebied van verwijderde bestanden.
De programmacodering voor een type niet – het destructieve programma voor het wissen van gegevens is als volgende gegeven:
///// Programma voor een niet-destructieve gegevenswisser \\\\\
#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 om automatisch tijdelijke bestanden te maken met een unieke naam */
strcpy(filename,"TTPT");
itoa(file_num,temp,10);
strcat(filename,temp);
strcat(filename,file_extension);
file_num++;
write_to_temp(filename);
}
} //// End of Main \\\\
///// Functie om de gegevens naar een tijdelijk bestand te schrijven \\\\\
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;
}
}
}
/* Functie om de tijdelijke bestanden automatisch te verwijderen */
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;
}
Opmerkingen over logica en de codering van het programma:
In dit programma volgen we in principe de volgende twee stappen om de niet-toegewezen ruimte van de schijf te wissen:
- Automatisch tijdelijke gegevensbestanden maken: Eerst maken we tijdelijke bestanden met unieke namen en met enkele gegevens erin totdat het schijfvolume vol is met deze tijdelijke gegevensbestanden. Door dit te doen, wordt het hele niet-toegewezen gegevensgebied van de logische schijfeenheid ingenomen door de gegevens van de tijdelijke bestanden en worden alle niet-toegewezen gegevens overschreven.
Hiervoor koos ik de namen van tijdelijke bestanden in de TTPTxxxx.PTT-indeling, wat betekent dat de eerste vier tekens van de tijdelijke bestanden TTPT zijn en de extensie van de bestanden .PTT. Dit wordt gedaan om de tijdelijke bestanden de unieke bestandsnamen te geven.
Ik heb de maximale grootte van het enkele tijdelijke bestand ingesteld, gelijk aan ongeveer 11.718 sectorgegevens, maar je kunt het naar eigen inzicht definiëren. Ik koos voor ruimtekarakter “ ” (ASCII-teken 32) om de gegevens in tijdelijke bestanden in te vullen. In plaats van spatie kunnen echter ook willekeurige tekens worden gebruikt.
- Alle tijdelijke bestanden verwijderen: Wanneer de logische schijfeenheid vol is met tijdelijke bestanden, geeft dit aan dat alle niet-toegewezen gegevensgebieden nu zijn overschreven. Nu worden alle tijdelijke bestanden die door het programma zijn gemaakt automatisch verwijderd. En zo wordt weggevaagde niet-toegewezen ruimte bereikt.
In de codering van het programma slaat de tekenarray bestandsnaam de bestandsnaam op om automatisch tijdelijke bestanden te genereren, met verschillende namen.
De functie write_to_temp(bestandsnaam); vult het tijdelijke bestand tot 11.718 sectoren (omdat er geen 10.000 sectoren voorkomen in gespecificeerde groep schrijven van buffer) equivalente gegevens met behulp van databuffer dbuf van 40.000 bytes. Er wordt 50 keer databuffer per keer geschreven om het schrijven te versnellen.
De tijdelijke bestanden worden gemaakt totdat het schijfvolume vol is en er een fout optreedt bij het maken van bestanden. De functie remove_temp_file() verwijdert alle tijdelijke bestanden die door het programma zijn gemaakt.
Op deze manier wordt alle niet-toegewezen ruimte weggevaagd zonder de gegevens van het schijfvolume te schaden.
Schrijfprogramma voor Destructieve Data Wiper:
Destructieve programma's voor het wissen van gegevens zijn programma's die rechtstreeks op het oppervlak van de schijf schrijven. Dit soort programma's voor het wissen van gegevens werken op een lager niveau dan het bestandssysteem en het besturingssysteem, wat betekent dat alle gegevens en andere logische informatie, inclusief besturingssysteem, bestandssystemen, directory-invoer en alles wat op de schijf is geschreven, wordt gewist.
Deze programma's voor het wissen van gegevens wissen direct de sectoren van het oppervlak van de schijf en wissen alles wat erop staat. Omdat alle gegevens van de schijf, inclusief het besturingssysteem, verloren gaan, worden deze programma's destructieve programma's voor het wissen van gegevens genoemd.
Dit soort wisprogramma's hebben de voorkeur in dergelijke gevallen, waarbij de gebruiker bereid is alles op de schijf te overschrijven, inclusief het besturingssysteem en alle gegevens op de schijf.
Er zijn echter nog meer voordelen van dit soort programma's voor het wissen van gegevens. Omdat deze destructieve programma's voor het wissen van gegevens volledig vrij van besturingssysteem en bestandssysteem werken en rechtstreeks op het oppervlak van de schijf schrijven, zijn ze redelijk sneller dan de niet-destructieve programma's voor het wissen van gegevens.
Als er ook maar een manier is om logische slechte sectoren op de schijf te creëren als gevolg van illegale opslag van enkele willekeurige gegevens, worden deze logische slechte sectoren ook volledig gewist met de gegevens van de schijf.
De codering voor een destructief programma voor het wissen van gegevens is hierna gegeven. Het programma is zo geschreven dat het ook grote schijven ondersteunt. Het programma wist de gegevens van de tweede fysieke harde schijf die op de computer is aangesloten.
///// Codering voor een destructief programma voor het wissen van gegevens \\\\\
#include<stdio.h>
#include<dos.h>
/* Structuur die moet worden gebruikt door de getdrivegeometry-functie met behulp van INT 13H-extensie, functienummer 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 */
} ;
/* Structuur van schijfadrespakketformaat, te gebruiken door de schrijfabsolutesectoren Functie */
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 */
} ;
///// Functie om aandrijfparameters te krijgen \\\\\
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 ) ;
/* Roep het gespecificeerde functienummer van de INT 13H-extensie op met Segment Register Values */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Head = %lu, Sectors Per Track = %lu, Cylinder =
%lu\n",
g.heads,g.spt,g.cyl);
/* Als de functie Drive Geometry mislukt, geeft u het foutbericht weer en sluit u af */
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();
/* Als totaal nr. van de aangesloten harde schijven is minder dan twee Display Error Message en Exit. */
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);
///// Eerst bevestigen, dan doorgaan \\\\\
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);
}
///// Bericht weergeven wanneer voltooid \\\\\
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();
}
//// Functie om absolute sector(en) te schrijven \\\\
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 */
/* voor gegevensbuffer */
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 */
/* Roep de gespecificeerde functie van INT 13H op met segmentregisterwaarden */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; //failure
else
return 1 ; // success
}
Opmerkingen over codering:
De structuurgeometrie wordt gebruikt door de getdrivegeometry-functie met behulp van INT 13H Extension, functienummer 0x48 om de verschillende parameters van de schijf te verkrijgen.
De structuur diskaddrpacket is voor het schijfadrespakketformaat, te gebruiken door de functie writeabsolutesectors.
De functie getdrivegeometry (int drive) is om Drive-parameters op te halen van het door de schijf gespecificeerde fysieke stationnummer. buffer [61440] is de gegevensbuffer van 61440 bytes, gelijk aan 120 sectoren.
(char) peekb(0x0040, 0x0075) wordt gebruikt om het aantal harde schijven te vinden dat op de computer is aangesloten, opgeslagen op de geheugenlocatie weergegeven door segment 0040H:offset 0075H. Als het totale aantal aangesloten harde schijven minder is dan twee Display Error Message en Exit.
De functie writeabsolutesectors ( 0x81, loop, 120, buffer ) wordt gebruikt om de gegevens van de gegevensbuffer op 120 sectoren tegelijk te schrijven, te beginnen met het absolute sectornummer dat door de lus is opgegeven.
Ik koos voor ‘\0’ (NULL-teken, ASCII-code 0) om op de sectoren te schrijven om de gegevens te overschrijven. U kunt echter willekeurige tekens gebruiken om de gegevens te overschrijven.
Voor een gedetailleerde beschrijving van de functies writeabsolutesectors en getdrivegeometry verwijzen we naar de hoofdstukken die eerder in dit boek zijn gegeven.
Gegevensgebied van specifiek bestand wissen
We hebben gesproken over de programma's voor het wissen van gegevens die de gegevens van niet-toegewezen ruimte op de schijf wissen of de hele schijf wissen. Maar als de gebruiker bereid is de gegevens elke keer te wissen wanneer hij de gegevens verwijdert, kan het een tijdrovend proces zijn om de volledige niet-toegewezen ruimte van de schijf te wissen.
We hebben dit soort programma's voor het wissen van gegevens nodig om het gegevensgebied te wissen dat alleen door dat specifieke bestand wordt ingenomen. Om dit te doen, krijgen we de hulp van FAT- en Root-directory-items om het gegevensgebied te vinden dat door die specifieke bestanden wordt ingenomen
Zelfs in het geval van een diskette, als de gegevens niet gefragmenteerd zijn, kunnen we dit alleen doen met behulp van de rootmapinformatie. De volgende tabel toont de informatie die is opgeslagen door een rootdirectory-item met 32 bytes, voor elk bestand:
Zoals we zien in de inhoudsopgave van de invoer in de rootdirectory, zijn we in staat om het begin- en eindcluster van de bestanden te vinden. De eerste byte van de bestandsnaam kan ook belangrijke informatie over het bestand bevatten. De informatie die door deze byte wordt gegeven, kan een van de onderstaande zijn:
Laten we deze informatie proberen om de gegevens te wissen van elk bestand dat is opgeslagen in 1.44Mb, 3 ½ inch diskette, met behulp van informatie over de hoofdmap. Ervan uitgaande dat de gegevens op de diskette niet gefragmenteerd zijn, wist het gegeven programma vervolgens de gegevens van het gespecificeerde bestand uit het gegevensgebied:
/* Programma om het gegevensgebied van het opgegeven bestand op diskette te wissen */
#include<stdio.h>
#include<dos.h>
///// Structuur om 32 bytes aan bestandsinvoer in hoofdmap te lezen \\\\\
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 */
};
/* Dit moet worden gebruikt om alle rootdirectory-vermeldingen te lezen */
//struct root entry[224];
/* Structuur om alle 16 bestandsvermeldingen in één sector van de hoofdmap te lezen */
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);
}
/* Informatie over bestanden weergeven na lezen uit hoofdmap */
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);
}
//// Gebruikersinvoer verkrijgen om het bestand te verwijderen \\\\
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);
}
///// Eerst bevestigen, dan doorgaan \\\\\\
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);
}
///// Bereken de bestandsgrootte in sectoren \\\\\
num_sectors = one.entry[i].file_size/512;
if((one.entry[i].file_size%512)>0)
{
num_sectors = num_sectors+1;
}
/* Gegevensbuffer van 512 bytes met 512 NULL-tekens */
for(j=0;j<512;j++)
{
wipe_buf[j] = '\0';
}
///// Startsector van het bestand \\\\\
j= one.entry[i].starting_cluster+31;
/* Wis het gegevensgebied tot de sectoren van het bestand eindigen */
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 */
///// Schrijf bovenstaande informatie in de hoofdmap \\\\\\
result= abswrite(0x00, 1, 19, &one);
if (result != 0)
{
perror("Error in Reading Sector, Press any key to
Exit...");
getch();
exit(1);
}
}
Opmerkingen over de logica en codering van het programma:
De structuur root wordt gebruikt om 32 bytes aan bestandsinvoer in de hoofdmap te lezen en structuur one_root_sector leest alle 16 bestandsvermeldingen in één sector van de hoofdmap
Als je alle sectoren van de rootdirectory-informatie wilt lezen, moet je dit als struct root-item [224] nemen; ik heb echter het programma geschreven om de 16 vermeldingen van slechts één sector van de hoofdmap te analyseren.
De startsector van het bestand is als volgt berekend:
j= one.entry[i].starting_cluster+31;
Dit wordt gedaan omdat het gegevensgebied van de 1,44 MB, 3 ½ inch diskette begint na de eerste 32 sectoren van de diskette. En op de diskette met de gespecificeerde capaciteit is één cluster van één sector.
De volgende tabel toont de logische kaart van 1,44 MB, 3½ inch diskette:
De uitvoer van het programma wordt als volgt weergegeven:
Hier hebben we de gegevens van het bestand PARTBOOT.C verwijderd en gewist. Als we de inhoud van de diskette zien met het DIR-commando, wordt het bestand PARBOOT.C daar niet weergegeven. Wanneer we het programma verder uitvoeren, wordt de invoer van het verwijderde bestand als volgt weergegeven:
Hier, het personage “” (0xE5), geeft aan dat het bestand is verwijderd. (zie de tabel voor het eerste teken van de bestandsnaam).
Als u hetzelfde programma voor de harde schijf wilt schrijven, moet u ook de FAT met de hoofdmap gebruiken om de informatie over het gegevensgebied van een bestand te krijgen.
Het is zo omdat de snelheid van gefragmenteerde gegevens op de harde schijven met de tijd toeneemt naarmate de oudere bestanden worden verwijderd en nieuwe bestanden worden gemaakt. Dan is het niet nodig dat alle gegevensclusters van een bestand op de schijf één voor één continu in het gegevensgebied blijven. Door FAT te openen, hebt u toegang tot al deze clusters.
Pagina aangepast op: 18/01/2022
Home