Hoofdstuk – 15
PROGRAMMERING VOOR DATA CLEANERS
Invoering
We hebben al besproken dat wanneer u een bestand van een schijf verwijdert, de informatie niet volledig van de schijf wordt verwijderd, maar wordt gemarkeerd als beschikbaar om er nieuwe gegevens naartoe te schrijven.
Wanneer we een schijf formatteren, worden alle gegevens over de bestanden en mappen op de schijf, zoals FAT- en rootdirectorygegevens, gewist. Het gegevensgebied blijft echter ongewijzigd en er wordt niets uit het gegevensgebied van de schijf gewist. Gegevens die door het besturingssysteem worden verwijderd of geformatteerd, blijven ongewijzigd in het gegevensgebied staan en kunnen met bepaalde gegevensherstelpogingen en gegevensherstelsoftware worden hersteld.
Om de gegevens volledig van de schijf te kunnen verwijderen, is er een programma nodig dat de gegevens volledig van de schijf kan verwijderen. Om dit te doen, is het niet voldoende om simpelweg bestanden te verwijderen of de schijf te formatteren; de gegevens op de schijf moeten worden overschreven met andere gegevens.
Programma's die worden gebruikt om gegevens volledig van een schijf te wissen, worden datawisprogramma's genoemd. Deze programma's schrijven willekeurige tekens in het gegevensgebied om de gegevens te overschrijven en alle informatie die eerder op de schijf was opgeslagen, te wissen.
Wanneer gegevens volledig onherstelbaar worden
Om gegevens te wissen, moet het gegevensgebied op de schijf worden overschreven met andere gegevens. Maar daarmee is het probleem nog niet opgelost. Om het nog ingewikkelder te maken, hebben magnetische schijven de neiging om overschreven gegevens te onthouden. Dit betekent dat de gegevens ook meerdere keren met willekeurige gegevensreeksen moeten worden overschreven. Hierdoor kunnen de gegevens zelfs met geavanceerde hulpmiddelen voor gegevensherstel niet worden hersteld.
Dit komt doordat er tegenwoordig technologieën beschikbaar zijn waarmee u gegevens kunt herstellen, zelfs na het gebruiken van eenvoudige hulpmiddelen voor het verwijderen van gegevens.
Sommige producten voor het wissen van gegevens overschrijven gegevens met binaire nullen en binaire enen. Het schrijven van een reeks binaire nullen en binaire enen levert het diepste herschrijfeffect op, omdat deze waarden respectievelijk de minimale en maximale magnetische waarden zijn.
Hoewel dit de theorie is van het ideale programma voor het wissen van gegevens, is het over het algemeen voldoende om de gegevens te overschrijven met een willekeurig ASCII-teken. De reden hiervoor is dat herstel met geavanceerde herstelhulpmiddelen en -technologieën niet kan worden gebruikt om gegevens van een organisatie te herstellen voor routinematig gegevensherstel, omdat deze technologieën erg duur zijn en zelfs miljoenen kosten voor één herstel. Bovendien zijn deze technologieën slechts in een paar landen ter wereld beschikbaar.
We bespreken alleen het eenvoudig overschrijven van gegevens om gegevens van de schijf te wissen. U kunt dezelfde programma's echter met weinig moeite zo aanpassen dat ze alleen willekeurige tekens schrijven. De gegevens die door dit idee worden gewist, kunnen ook niet worden hersteld met welke dataherstelsoftware dan ook.
Waarom is het verwijderen van gegevens zo belangrijk?
Wanneer we methoden voor gegevensherstel bespreken, verzekeren we de gebruiker dat de gegevens kunnen worden hersteld met enkele algemene of enkele speciale gegevensherstelpogingen. Maar gegevensherstel is niet voor iedereen een gewenste en verwachte functie.
Er zijn waarschijnlijk veel mensen of organisaties die altijd bereid zijn om de gegevens op hun schijf te wissen, op een manier die op geen enkele manier meer te herstellen is. In dergelijke gevallen kan de schijf voorheen zeer gevoelige gegevens bevatten. Als deze in verkeerde handen vallen, kan dit schade aan de organisatie of gebruiker veroorzaken door onjuist gebruik van de informatie.
Zoals we weten, groeit de behoefte aan steeds meer harde schijfruimte elke dag. Als gevolg hiervan worden in vrijwel elke organisatie jaarlijks op grote schaal oude schijven met een lage capaciteit vervangen door nieuwe schijven met een hoge capaciteit. Als deze oude schijven in de verkeerde handen vallen, kan dat voor deze organisatie een groot probleem opleveren.
Volgens een nieuwsbericht dat op 16 januari 2003 werd gepubliceerd door CNET News.com, kochten MIT-studenten Simon Garfinkel en Abby Shelat oude harde schijven voor onderzoeksdoeleinden via internet en andere verkooppunten. Op die manier kregen ze toegang tot grote hoeveelheden persoonlijke informatie die mensen niet eens de moeite nemen te verwijderen.
Nadat ze 158 schijven voor ongeveer 1000 dollar hadden gekocht, wisten ze meer dan 5000 creditcardnummers, medische dossiers, gedetailleerde persoonlijke en zakelijke financiële informatie en meerdere gigabytes aan e-mails, broncodes en andere informatie te verzamelen.
De twee studenten hebben 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 conclusies die uit het onderzoek naar voren kwamen, zijn dat de tweedehandsmarkt voor harde schijven bol staat van de persoonlijke informatie. Daardoor kan een kwaadwillende koper zich heel gemakkelijk voordoen als iemand anders.
Schrijfprogramma voor niet-destructieve datawisser
De niet-destructieve datawisser is een soort datawisprogramma waarmee we de gehele “niet-toegewezen ruimte” van het schijfvolume kunnen wissen, zonder de gegevens die op de schijf zijn opgeslagen op enigerlei wijze te beschadigen.
De reikwijdte van een dergelijke data wiper is in de gevallen waarin u alle niet-toegewezen ruimte van het schijfvolume wilt wissen terwijl de toegewezen data die in het volume is opgeslagen onaangeroerd moet blijven. Dit type data wiper programma wist ook het datagebied van verwijderde bestanden.
De programmacodering voor een type niet-destructief data-wisprogramma is hieronder gegeven:
///// Programma voor een niet-destructieve gegevenswisser \\\\\
#include <stdio.h>
unsigned int file_num=0; /* Geeft bestandsnummer
Tijdens het automatisch aanmaken
van tijdelijke gegevensbestanden */
float status=0; /* Hoeveel schijfruimte is er beschikbaar?
nog steeds geschreven */
static char dbuf[40000]; /* Gegevensbuffer om te schrijven
Tijdelijke bestanden met */
char file_extension[5]=".ptt";/* Unieke extensies voor
Tijdelijke bestanden */
char temp[5]; /* Bestandsnummer omgezet naar
Snaar */
char bestandsnaam[40]; /* Tijdelijke bestandsnaam */
leeg hoofd()
{
ongetekende int i=0;
clrscr();
terwijl(i<40000)
{
dbuf[i] = ' ';
ik++;
}
gotoxy(10,14);cprintf(" MB Nog Steeds Geschreven...");
terwijl(1)
{
/* Logica om automatisch tijdelijke bestanden met een unieke naam te maken */
strcpy(bestandsnaam,"TTPT");
itoa(bestandsnummer,temp,10);
strcat(bestandsnaam,temp);
strcat(bestandsnaam,bestandsextensie);
bestandsnummer++;
write_to_temp(bestandsnaam);
}
} //// Einde van Main \\\\
///// Functie om de gegevens naar een tijdelijk bestand te schrijven \\\\\
write_to_temp(char *bestandsnaam)
{
ongetekende int i, aantal=1;
vlotter buf_status=0;
BESTAND *tt;
als((tt=fopen(bestandsnaam,"wb"))==NULL)
{
fsluiten(tt);
printf("\n Er is een fout opgetreden bij het maken van tijdelijke
bestand, ");
printf("\n Tijdelijke bestanden verwijderen na KEY BOARD
HIT");
halen();
remove_temp_file();/* Verwijder alle tijdelijke bestanden */
}
terwijl(1)
{
voor(i=0;i<50;i++)
{
fprintf(tt,"%s",dbuf);
}
buf_status = (float)((40000*50*aantal)/512);
status=status+(40000*50);
tellen++;
gotoxy(10,14);
cprintf("%.0f",(float)(status/1000000));
als(kbhit())
{
fsluiten(tt);
printf("\n Tijdelijke bestanden verwijderen, alstublieft
Wachten...");
verwijder_tijdelijk_bestand();
}
als(buf_status>=10000)
{
fsluiten(tt);
opbrengst;
}
}
}
/* Functie om tijdelijke bestanden automatisch te verwijderen */
verwijder_tijdelijk_bestand()
{
int i=0;
voor(i=0;i<=bestandsnummer;i++)
{
strcpy(bestandsnaam,"TTPT");
dit(i,temp,10);
strcat(bestandsnaam,temp);
strcat(bestandsnaam,bestandsextensie);
verwijder(bestandsnaam);
}
uitgang(1);
retourneer 0;
}
Opmerkingen over de 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:
- Maak automatisch tijdelijke databestanden: Eerst maken we tijdelijke bestanden met unieke namen en met wat data erin totdat het schijfvolume vol is met deze tijdelijke databestanden. Door dit te doen, wordt alle niet-toegewezen datagebied van de logische schijf ingenomen door de data van de tijdelijke bestanden en worden alle niet-toegewezen data overschreven.
Om dit te doen, heb ik de namen van tijdelijke bestanden gekozen in het TTPTxxxx.PTT formaat, wat betekent dat de eerste vier tekens van de tijdelijke bestanden TTPT zijn en de extensie van de bestanden .PTT is. 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 sectoren data, maar u kunt het naar eigen inzicht definiëren. Ik heb het spatiekarakter “ ” (ASCII-karakter 32) gekozen om de data in tijdelijke bestanden te vullen. Er kunnen echter ook willekeurige karakters worden gebruikt in plaats van spaties.
- Verwijder alle tijdelijke bestanden: Wanneer de logische schijf vol is met tijdelijke bestanden, geeft dit aan dat alle niet-toegewezen datagebieden nu worden overschreven. Nu worden alle tijdelijke bestanden die door het programma zijn gemaakt automatisch verwijderd. En zo wordt de niet-toegewezen ruimte weggevaagd.
Bij het coderen van het programma wordt de bestandsnaam in de tekenreeks bestandsnaam opgeslagen, zodat er automatisch tijdelijke bestanden met verschillende namen worden gegenereerd.
De functie write_to_temp(bestandsnaam); vult het tijdelijke bestand tot 11.718 sectoren (omdat er geen 10.000 sectoren voorkomen in de opgegeven groep die de buffer schrijft) met behulp van een dbuf voor gegevens van 40.000 bytes. Er worden 50 gegevens tegelijk naar de buffer 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 het bestand. De functie remove_temp_file() verwijdert alle tijdelijke bestanden die door het programma zijn gemaakt.
Op deze manier wordt alle niet-toegewezen ruimte verwijderd zonder dat de gegevens op het schijfvolume worden beschadigd.
Schrijfprogramma voor Destructive Data Wiper:
Destructieve data wiping programma's zijn programma's die direct op het oppervlak van de schijf schrijven. Dit type data wiping programma's werkt op een lager niveau dan bestandssysteem en besturingssysteem, wat betekent dat alle data en andere logische informatie, inclusief OS, bestandssystemen, directory-items en alles wat op de schijf is geschreven, wordt gewist.
Deze data wiping programma's wissen direct de sectoren van het oppervlak van de schijf, en wissen alles wat erop geschreven is. Omdat alle data van de schijf, inclusief het besturingssysteem, verloren gaat, worden deze programma's destructieve data wiping programma's genoemd.
Dit soort wisprogramma's worden in dergelijke gevallen gebruikt, 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 type data wiping programma's. Omdat deze destructieve data wiping programma's volledig vrij van OS en bestandssysteem werken en direct op het oppervlak van de schijf schrijven, zijn ze redelijk sneller dan de niet-destructieve data wipers.
Ook als er door de illegale opslag van willekeurige gegevens logische slechte sectoren op de schijf ontstaan, worden deze logische slechte sectoren samen met de gegevens op de schijf volledig gewist.
De codering voor een destructief data wiping programma is hierna gegeven. Het programma is geschreven om ook grote schijven te ondersteunen. Het programma wist de data van een tweede fysieke harde schijf die is aangesloten op de computer.
///// Codering voor een destructief datawisprogramma \\\\\
#include<stdio.h>
#include<dos.h>
/* Structuur die gebruikt moet worden door de getdrivegeometry-functie met behulp van de INT 13H-extensie, functienummer 0x48. */
structuur geometrie
{
unsigned int size ; /* (call) grootte van Buffer */
niet-ondertekende int-vlaggen; /* Informatievlaggen */
ongetekende lange cilinder; /* Aantal fysieke cilinders op
Drijfveer */
ongetekende lange hoofden ;/* Aantal fysieke hoofden op
Drijfveer */
unsigned long spt ; /* Aantal fysieke sectoren per
Spoor */
ongetekende lange sectoren[2] ; /* Totaal aantal
Sectoren op Drive */
ongetekende int bps ; /* Bytes per sector */
} ;
/* Structuur van het schijfadrespakketformaat, te gebruiken door de writeabsolutesectors-functie */
structuur diskaddrpacket
{
char packetsize ; /* Grootte van pakket,
over het algemeen 10H */
char gereserveerd ; /* Gereserveerd (0) */
int blockcount ; /* Aantal blokken om te
Overdracht */
char far *bufferadres ; /* adres om over te dragen
Buffertje */
ongetekend lang bloknummer[2] ; /* Beginnend Absoluut
Bloknummer */
} ;
///// Functie om schijfparameters op te halen \\\\\
ongetekende lange getdrivegeometry (int drive)
{
vakbond REGS i, o;
structuur SREGS s;
structuurgeometrie g = { 26, 0, 0, 0, 0, 0, 0, 0 } ;
ihah = 0x48 ; /* Functienummer 0x48 van INT 13H
Extensies */
ihdl = drive; /* Schijfnummer */
ixsi = FP_OFF ( (void ver*)&g ) ;
s.ds = FP_SEG ( (void far*)&g ) ;
/* Roep het opgegeven functie nummer van de INT 13H extensie aan met Segment Register Waarden */
int86x ( 0x13, &i, &o, &s );
printf("\n Hoofd = %lu, Sectoren per spoor = %lu, Cilinder =
%lu\n",
g.koppen,g.spt,g.cyl);
/* Als de Get Drive Geometry-functie mislukt, wordt een foutmelding weergegeven en wordt het programma afgesloten */
als(g.spt==0)
{
printf("\n Get Drive Geometry-functie mislukt....");
printf("\n Extensies worden niet ondersteund, druk op een willekeurige toets om
Uitgang...");
halen();
uitgang(1);
}
return *g.sectors; /* Retourneer het aantal
Sectoren op Drive */
}
leeg hoofd()
{
ongetekende lange lus=0, Sectoren_in_HDD2=0;
unsigned char buffer[61440]; /* Gegevensbuffer van 61440
bytes Gelijk aan
120 Sectoren */
ongetekend lang i=0;
keuze van karakter;
clrscr();
/* Als het totale aantal aangesloten harde schijven minder dan twee is, wordt een foutmelding weergegeven en wordt het programma afgesloten. */
als(((char)peekb(0x0040, 0x0075))<2)
{
printf("\n\n U moet minimaal twee harde schijven hebben
Aangesloten op uw computer om dit uit te voeren");
printf("\n Programma. Dit programma is ontwikkeld
om de gegevens van de tweede harde schijf te wissen.");
printf("\n Druk op een toets om af te sluiten... ");
halen();
uitgang(1);
}
Sectoren_in_HDD2 = getdrivegeometry (0x81);
printf("Totaal aantal sectoren op tweede harde schijf =
%lu\n\n",
Sectoren_in_HDD2);
///// Eerst bevestigen, dan doorgaan \\\\\
printf("\n Het is een programma voor het wissen van gegevens en schrijft op
het oppervlak van de schijf,");
printf("\n Nadat dit programma is uitgevoerd, kunnen gegevens niet worden
worden hersteld door welke Software dan ook,");
printf("\n Alle gegevens op de tweede harde schijf worden
kwijt !!!");
printf("\n Druk op \'Y\' om door te gaan, anders een willekeurige toets om
Uitgang... ");
keuze = getche();
schakelaar(keuze)
{
geval 'y':
geval 'Y':
pauze;
standaard:
uitgang(0);
}
gotoxy(10,15);cprintf(" Initialiseren, even geduld...");
voor(i=0;i<61440;i++)
{
buffer[i]='\0';
}
gotoxy(10,15);cprintf(" ");
gotoxy(10,15);
printf("Momenteel absolute sector wissen: ");
for(loop=0;loop<= Sectoren_in_HDD2;loop=loop+120)
{
writeabsolutesectors (0x81, lus, 120, buffer);
gotoxy(44,15); printf("%ld",loop);
als(kbhit())
{
uitgang(0);
}
///// Bericht weergeven wanneer voltooid \\\\\
printf("\n\n Het wissen van gegevens is nu voltooid, alle gegevens in
Tweede harde schijf is nu");
printf("\n Volledig gewist, druk op een toets om af te sluiten...");
halen();
}
//// Functie om absolute sector(en) te schrijven \\\\
int writeabsolutesectors (int drive, unsigned long sectornummer, int aantal sectoren, void *buffer)
{
vakbond REGS i, o;
structuur SREGS s;
structuur diskaddrpacket pp;
pp.packetsize = 16 ; /* Pakketgrootte = 10H */
pp.reserved = 0 ; /* Gereserveerd = 0 */
pp.blockcount = numofsectors ;/* Aantal sectoren dat moet worden
geschreven worden */
/* voor gegevensbuffer */
pp.bufferadres = (char ver*) MK_FP ( FP_SEG((void ver*)buffer), FP_OFF((void ver*)buffer));
pp.blocknumber[0] = sectornummer ; /* Sectornummer
geschreven worden*/
pp.blocknumber[1] = 0 ; /* Bloknummer = 0 */
ihah = 0x43 ; /* Functie Nummer */
ihal = 0x00 ; /* Schrijf vlaggen */
ihdl = drive ; /* Fysieke schijf
nummer */
ixsi = FP_OFF ( (void far*)&pp ); /* ds:si voor
bufferparameters */
s.ds = FP_SEG ( (void ver*)&pp ) ; /* ds:zeg voor
bufferparameters */
/* Roep de opgegeven functie van INT 13H aan met segmentregisterwaarden */
int86x ( 0x13, &i, &o, &s );
als (oxcflag==1)
retourneer 0 ; //mislukt
anders
retour 1 ; // succes
}
Opmerkingen over codering:
De structuurgeometrie wordt gebruikt door de functie getdrivegeometry met behulp van de INT 13H-extensie, functienummer 0x48 om de verschillende parameters van de schijf op te halen.
De structuur diskaddrpacket is bedoeld voor het schijfadrespakketformaat, dat gebruikt moet worden door de functie writeabsolutesectors.
De functie getdrivegeometry (int drive) is bedoeld om schijfparameters op te halen van de opgegeven fysieke schijf met het nummer drive. buffer [61440] is de gegevensbuffer van 61440 bytes, wat overeenkomt met 120 sectoren.
(char) peekb(0x0040, 0x0075) wordt gebruikt om het aantal harde schijven te vinden dat op de computer is aangesloten, opgeslagen op een geheugenlocatie die wordt weergegeven door segment 0040H:offset 0075H. Als het totale aantal aangesloten harde schijven minder is dan twee, wordt een foutmelding weergegeven en wordt de computer afgesloten.
De functie writeabsolutesectors (0x81, loop, 120, buffer) wordt gebruikt om de gegevens van de gegevensbuffer in 120 sectoren tegelijk te schrijven, beginnend bij het absolute sectornummer dat door loop is opgegeven.
Ik heb '\0' (NULL-teken, ASCII-code 0) gekozen om op de sectoren te schrijven om de data te overschrijven. U kunt echter willekeurige tekens gebruiken om de data te overschrijven.
Voor een gedetailleerde beschrijving van de functies writeabsolutesectors en getdrivegeometry raadpleegt u de hoofdstukken eerder in dit boek.
Gegevensgebied van een specifiek bestand wissen
We hebben het gehad over de data wiping programma's die de data van niet-toegewezen ruimte van de schijf wissen of de hele schijf wissen. Maar als de gebruiker bereid is om de data te wissen telkens wanneer hij de data verwijdert, kan het een tijdrovend proces zijn om de hele niet-toegewezen ruimte van de schijf te wissen.
We hebben dit soort data wiping programma's nodig om het data gebied te wissen dat alleen bezet is door dat specifieke bestand. Om dit te doen, krijgen we de hulp van FAT en Root directory entries, om het data gebied te vinden dat bezet is door dat specifieke bestand
Zelfs in het geval van floppy, als de data niet gefragmenteerd is, kunnen we dit alleen doen met behulp van Root directory informatie. De volgende tabel toont de informatie die is opgeslagen door een root directory entry met 32 bytes, voor elk bestand:
Zoals we zien in de inhoudsopgave van de root directory entry, zijn we in staat om de begin- en eindcluster van de bestanden te vinden. De eerste byte van de bestandsnaam kan ook wat 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 van elk bestand opgeslagen op 1,44 Mb, 3 ½ inch floppy disk te wissen, met behulp van root directory informatie. Ervan uitgaande dat de gegevens op de floppy disk niet gefragmenteerd zijn, wist het gegeven programma vervolgens de gegevens van het opgegeven bestand uit zijn data gebied:
/* Programma om het gegevensgebied van het opgegeven bestand op de floppydisk te wissen */
#include<stdio.h>
#include<dos.h>
///// Structuur om 32 bytes van een bestandsvermelding in de hoofdmap te lezen \\\\\
structuur wortel
{
unsigned char bestandsnaam[8]; /* Bestandsnaam Invoer van
8 Bytes */
ongetekende char-extensie[3]; /* Extensie van bestand van
3 Bytes */
ongetekend char-kenmerk; /* Bestandskenmerkbyte */
ongetekende char gereserveerd[10]; /* Gereserveerde bytes 10 */
unsigned int tijd; /* Tijd, 2 Bytes */
unsigned int datum; /* Datum, 2 Bytes */
unsigned int starting_cluster;/* Startcluster van bestand,
2 Bytes */
unsigned long file_size; /* Bestandsgrootte in bytes,
4 Bytes */
};
/* Dit moet worden opgevat als het lezen van alle rootdirectory-items */
//struct root-invoer[224];
/* Structuur om alle 16 bestandsvermeldingen in één sector van de hoofdmap te lezen */
struct één_wortel_sector
{
struct root-invoer[16];
};
struct one_root_sector één;
leeg hoofd()
{
int resultaat, i, aantal_sectoren,j;
char wipe_buf[512]; /* Gegevensbuffer die gebruikt moet worden om te wissen
uit de gegevens Gebied van bestand */
clrscr();
resultaat = absread(0x00, 1, 19, &one); /* Lees absolute sector
19 (Eerste sector van de rootdirectory) */
als (resultaat != 0)
{
perror("Fout in leessector, druk op een toets om
Uitgang...");
halen();
uitgang(1);
}
/* Bestandsinformatie weergeven na het lezen uit de hoofdmap */
printf(" BESTANDSNR. BESTANDSNAAM EXTENSIE STARTCLUSTER
BESTANDSGROOTTE \n\n");
voor(i=1;i<16;i++)
{
printf("\n %5d %8.8s %3.3s %5u %10lu ",
ik, een.entry[i].bestandsnaam, een.entry[i].extensie,
one.entry[i].startcluster, one.entry[i].bestandsgrootte);
}
//// Haal gebruikersinvoer op om het bestand te verwijderen \\\\
printf("\n\n Voer het bestandsnummer in dat u wilt verwijderen en
Volledig uitwissen ");
scanf("%d", &i);
als(i<1 || i>15)
{
printf(" \"%d\" is een ongeldige keuze..., druk op een willekeurige
Sleutel om af te sluiten...", i);
halen();
uitgang(1);
}
///// Eerst bevestigen, dan doorgaan \\\\\\
printf("\n Je staat op het punt om uit te wissen,
Het bestand \"%.8s.%s\"",
one.entry[i].bestandsnaam,
één.entry[i].extensie);
printf("\n Wilt u doorgaan...(J/N) ");
schakelaar(getche())
{
geval 'y':
geval 'Y':
pauze;
standaard:
uitgang(0);
}
///// Bereken de bestandsgrootte in sectoren \\\\\
num_sectors = one.entry[i].file_size/512;
als((one.entry[i].bestandsgrootte%512)>0)
{
aantal_sectoren = aantal_sectoren+1;
}
/* Gegevensbuffer van 512 bytes met 512 NULL-tekens */
voor(j=0;j<512;j++)
{
wipe_buf[j] = '\0';
}
///// Startsector van het bestand \\\\\
j= one.entry[i].starting_cluster+31;
/* Wis het gegevensgebied totdat de sectoren van het bestand eindigen */
poe(j!=(one.entry[i].starting_cluster +
aantal_sectoren+31) )
{
als((abswrite(0x00, 1, j, &wipe_buf))!=0)
{
printf("\n Fout bij het schrijven naar schijfsectoren");
krijgen();
uitvoer(0);
}
j++;
}
printf("\n\n Bestand \"%.8s.%.3s\" Verwijderd !!!" ,
one.entry[i].bestandsnaam,
één.entry[i].extensie);
one.entry[i].attribute = 0; /* Stel bestandskenmerk in
naar 0 */
one.entry[i].time = 0; /* Tijdinformatie wissen
bestand */
een.entry[i].datum = 0; /* Datuminformatie wissen
bestand */
one.entry[i].starting_cluster = 0; /* Stel het initiële cluster in op 0
*/
one.entry[i].file_size = 0; /* Stel bestandsgrootte in op 0 */
one.entry[i].bestandsnaam[0]=0xE5; /* Geef afstandsbediening
Bestandsstatus in bestand */
///// Schrijf de bovenstaande informatie naar de hoofdmap \\\\\\
resultaat = abswrite(0x00, 1, 19, &one);
als (resultaat != 0)
{
perror("Fout bij het lezen van de sector, druk op een toets om
Uitgang...");
krijgen();
uitvoer(1);
}
}
Opmerkingen over de logica en codering van het programma:
De root-structuur wordt gebruikt om 32 bytes van een bestandsvermelding in de root-directory te lezen, en de one_root_sector-structuur leest alle 16 bestandsvermeldingen in één sector van de root-directory.
Als u alle sectoren van de root-directory-informatie wilt lezen, moet u dit als een struct root[224]-item beschouwen; Ik heb echter een programma geschreven om 16 records van slechts één sector van de hoofdmap te analyseren.
De startsector van het bestand wordt als volgt berekend:
j= één.record[i].initiële_cluster+31;
Dit komt doordat het datagebied van een 1,44 MB, 3 ½ inch floppydisk begint na de eerste 32 sectoren van de schijf. En op een floppy disk met de opgegeven capaciteit komt één cluster overeen met één sector.
De volgende tabel toont de logische kaart van een 1,44 MB, 3½-inch floppydisk:
Het resultaat van het programma wordt als volgt weergegeven:
Hier hebben we de gegevens van het bestand PARTBOOT.C verwijderd en gewist. Wanneer we de inhoud van de floppy disk bekijken met behulp van de DIR-opdracht, wordt het bestand PARTBOOT.C daar niet weergegeven. Wanneer het programma verder wordt uitgevoerd, wordt de vermelding voor het verwijderde bestand als volgt weergegeven:
Hier betekent het symbool "" (0xE5) dat het bestand is verwijderd. (zie tabel voor het eerste teken van de bestandsnaam).
Als u hetzelfde programma voor de harde schijf wilt schrijven, moet u ook FAT gebruiken met de hoofdmap om informatie over het gegevensgebied van een bestand te verkrijgen.
Dit komt doordat de mate van gegevensfragmentatie op harde schijven in de loop van de tijd toeneemt, omdat oude bestanden worden verwijderd en nieuwe worden gemaakt. Dan is het niet nodig dat alle dataclusters van een bestand op de schijf achter elkaar in het gegevensgebied blijven staan. Als u toegang hebt tot FAT, hebt u toegang tot al deze clusters.
