Kapitel – 15
Programmierung für Datenwischer
Einführung
Wir haben das bereits besprochen, wenn wir eine Datei von der Festplatte löschen, werden die Informationen nicht vollständig vom Laufwerk gelöscht, sondern als verfügbar markiert, damit neue Daten darüber geschrieben werden können.
Wenn wir ein Laufwerk formatieren, werden alle Informationen von Dateien und Verzeichnissen des Laufwerks wie FATs und Root-Verzeichniseinträge gelöscht, aber der Datenbereich bleibt unverändert und nichts aus dem Datenbereich der Festplatte wird gelöscht. Die Daten, die mit dem Betriebssystem gelöscht oder formatiert werden, bleiben unverändert im Datenbereich und können mit einigen Datenwiederherstellungsbemühungen und Datenwiederherstellungssoftware wiederhergestellt werden.
Daher führt die Notwendigkeit, Daten vollständig von einem Laufwerk zu löschen, zu der Forderung nach einem solchen Programm, das die Daten vollständig von der Platte löscht. Dazu reicht es nicht aus, nur die Dateien zu löschen oder das Laufwerk zu formatieren, sondern die Daten auf der Festplatte müssen durch andere Daten überschrieben werden.
Die Programme, die verwendet werden, um die Daten vollständig von der Festplatte zu löschen, werden als Datenlöschprogramme bezeichnet. Diese Programme schreiben zufällige Zeichen in den Datenbereich, um Daten zu überschreiben und alle zuvor auf der Festplatte gespeicherten Informationen zu löschen.
Wenn die Daten nicht mehr wiederherstellbar sind
Um die Daten zu löschen, sollte der Datenbereich der Festplatte mit einigen anderen Daten darauf überschrieben werden, aber das Problem endet hier nicht. Um die Dinge noch komplizierter zu machen, erfordert die Tendenz von Magnetlaufwerken, sich überschriebene Daten zu merken, dass Daten auch mehrmals durch zufällige Datenfolgen überschrieben werden, so dass sie selbst mit ausgefeilten Datenwiederherstellungswerkzeugen nicht wiederhergestellt werden können.
Dies liegt daran, dass heute Technologien verfügbar sind, die Daten auch nach der Verwendung einiger einfacher Datenlöscher wiederherstellen können.
Einige Datenlöschprodukte führen binäre Nullen und binäre Einsen durch, die Daten überschreiben. Das Schreiben einer Reihe von binären Nullen und binären Einsen erzielt den tiefsten Überschreibeffekt, da diese Werte die minimalen bzw. maximalen magnetischen Werte sind.
Dies ist zwar die Theorie eines idealen Datenlöschprogramms, aber im Allgemeinen reicht das Überschreiben von Daten durch zufällige ASCII-Zeichen aus. Der Grund dafür ist, dass die Wiederherstellung durch ausgeklügelte Wiederherstellungstools und -technologie nicht zur Wiederherstellung der Daten einer Organisation für eine routinemäßige Datenwiederherstellung verwendet werden kann, da diese Technologien sehr teuer sind und selbst für eine einzelne Wiederherstellung Millionen kosten. Darüber hinaus sind diese Technologien nur in wenigen Ländern der Welt verfügbar.
Wir werden nur das einfache Überschreiben von Daten diskutieren, um die Daten von der Platte zu löschen. Sie können jedoch dieselben Programme nur mit geringem Aufwand weiter modifizieren, um die zufälligen Zeichen zu schreiben. Daten, die durch diese Idee ausgelöscht wurden, können auch von keiner Datenwiederherstellungssoftware wiederhergestellt werden.
Warum das Löschen von Daten so wichtig ist
Wenn wir über die Datenwiederherstellungstechniken sprechen, versichern wir dem Benutzer, dass die Daten mit einigen allgemeinen oder bestimmten Datenwiederherstellungsversuchen wiederhergestellt werden können. Aber die Datenwiederherstellung ist nicht immer eine gewünschte und erwartete Funktion für alle.
Es kann viele Personen oder Organisationen geben, die immer bereit sind, die Daten ihrer Festplatte so zu löschen, dass sie auf keinen Fall wiederhergestellt werden sollten. In solchen Fällen können zuvor sehr sensible Daten auf der Festplatte gespeichert sein, die, wenn sie in falsche Hände geraten, der Organisation oder dem Benutzer durch Missbrauch der Informationen schaden können.
Wie wir wissen, steigt der Bedarf an immer mehr Speicherplatz auf Festplatten von Tag zu Tag. Infolgedessen werden die älteren Laufwerke mit kleiner Kapazität jedes Jahr in großem Umfang in fast jeder Organisation durch neue Laufwerke mit großer Kapazität ersetzt. Wenn diese älteren Festplatten in die falschen Hände geraten, kann dies ein sehr ernstes Problem für diese Organisation darstellen.
Laut Nachrichten, die am 16. Januar 2003 von CNET News.com veröffentlicht wurden, haben die Studenten des Massachusetts Institute of Technology, Simon Garfinkel und Abbi Shelat, im Namen der Forschung alte Festplatten aus dem Internet gekauft und andere Second-Hand-Verkäufe entdeckt Die riesigen Mengen an persönlichen Informationen, die die Menschen nicht löschen.
Nach dem Kauf von 158 Laufwerken für rund 1000 US-Dollar gelang es ihnen, über 5000 Kreditkartennummern, Krankenakten, detaillierte persönliche und geschäftliche Finanzinformationen und mehrere Gigabyte an E-Mails, Quellcodes und anderen Informationen zu sammeln.
Die beiden Studenten haben ihre Ergebnisse in einem Bericht mit dem Titel "Remembrance of Data Passed: A Study of Disk Sanitation" zusammengestellt. veröffentlicht in der Februarausgabe von IEEE Security and Privacy.
Die wichtigsten Ergebnisse der Untersuchung sind, dass der Gebrauchtmarkt für Festplatten mit persönlichen Informationen gefüllt ist, was es einem böswilligen Käufer sehr einfach macht, die Identität einer anderen Person anzunehmen.
Schreibprogramm für Non–Destructive Data Wiper
Der zerstörungsfreie Datenlöscher ist eine Art Datenlöschprogramm, mit dem wir den gesamten „nicht zugeordneten Speicherplatz” des Festplattenvolumens, ohne die auf der Festplatte gespeicherten Daten in irgendeiner Weise zu beschädigen.
Der Anwendungsbereich eines solchen Datenlöschers liegt in den Fällen, in denen Sie den gesamten nicht zugeordneten Speicherplatz des Datenträgers löschen möchten, während die im Datenträger gespeicherten zugeordneten Daten unberührt bleiben sollen. Diese Art von Datenlöschprogramm löscht auch den Datenbereich gelöschter Dateien.
Die Programmcodierung für eine Art Nicht-– Als nächstes wurde ein destruktives Datenlöschprogramm angegeben:
///// Programm für einen zerstörungsfreien Datenlöscher \\\\\
#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)
{
/* Logik zum automatischen Erstellen temporärer Dateien mit eindeutigem Namen */
strcpy(filename,"TTPT");
itoa(file_num,temp,10);
strcat(filename,temp);
strcat(filename,file_extension);
file_num++;
write_to_temp(filename);
}
} //// End of Main \\\\
///// Funktion zum Schreiben der Daten in eine temporäre Datei \\\\\
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;
}
}
}
/* Funktion zum automatischen Löschen der temporären Dateien */
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;
}
Anmerkungen zur Logik und zur Codierung des Programms:
In diesem Programm folgen wir grundsätzlich den folgenden zwei Schritten, um den nicht zugeordneten Speicherplatz der Festplatte zu löschen:
- Temporäre Datendateien automatisch erstellen: Zuerst erstellen wir temporäre Dateien mit eindeutigen Namen und einigen Daten, bis der Datenträger mit diesen temporären Datendateien voll ist. Dadurch wird der gesamte nicht zugeordnete Datenbereich des logischen Laufwerks durch die Daten der temporären Dateien belegt und alle nicht zugeordneten Daten werden überschrieben.
Dazu habe ich die Namen der temporären Dateien im Format TTPTxxxx.PTT gewählt, das heißt, die ersten vier Zeichen der temporären Dateien sind TTPT und die Erweiterung der Dateien ist .PTT. Dies geschieht, um den temporären Dateien eindeutige Dateinamen zu geben.
Ich habe die maximale Größe der einzelnen temporären Datei festgelegt, die ungefähr 11.718 Sektordaten entspricht, aber Sie können sie nach Ihren Wünschen definieren. Ich habe das Leerzeichen „ “ (ASCII-Zeichen 32), um die Daten in temporäre Dateien zu füllen. Anstelle von Leerzeichen können jedoch auch beliebige Zeichen verwendet werden.
- Alle temporären Dateien entfernen: Wenn das logische Laufwerk voll mit temporären Dateien ist, zeigt dies an, dass der gesamte nicht zugeordnete Datenbereich jetzt überschrieben ist. Jetzt werden alle vom Programm erstellten temporären Dateien automatisch entfernt. Und somit wird nicht zugeordneter Speicherplatz ausgelöscht.
In der Codierung des Programms speichert das Zeichenarray filename den Dateinamen, um automatisch temporäre Dateien mit unterschiedlichen Namen zu erzeugen.
Die Funktion write_to_temp(filename); füllt die temporäre Datei mit Hilfe des Datenpuffers dbuf von 40.000 Bytes auf bis zu 11.718 Sektoren (weil es kein Auftreten von 10.000 Sektoren in der angegebenen Gruppe gibt). Es wird jeweils 50 Mal in den Datenpuffer geschrieben, um das Schreiben zu beschleunigen.
Die temporären Dateien werden erstellt, bis der Datenträger voll ist und ein Dateierstellungsfehler auftritt. Die Funktion remove_temp_file() entfernt alle temporären Dateien, die vom Programm erstellt wurden.
Auf diese Weise wird der gesamte nicht zugeordnete Speicherplatz gelöscht, ohne die Daten des Datenträgers zu beschädigen.
Schreibprogramm für Destructive Data Wiper:
Zerstörerische Datenlöschprogramme sind solche, die direkt auf die Oberfläche der Platte schreiben. Diese Art von Datenlöschprogrammen arbeitet auf einer niedrigeren Ebene als Dateisystem und Betriebssystem, was bedeutet, dass alle Daten und andere logische Informationen, einschließlich Betriebssystem, Dateisysteme, Verzeichniseinträge und alles, was auf der Festplatte geschrieben ist, gelöscht werden.
Diese Datenlöschprogramme löschen direkt die Sektoren der Oberfläche der Festplatte und löschen alles, was darauf geschrieben ist. Da alle Daten der Festplatte einschließlich des Betriebssystems verloren gehen, werden diese Programme als destruktive Datenlöschprogramme bezeichnet.
Diese Arten von Löschprogrammen werden in solchen Fällen bevorzugt, in denen der Benutzer bereit ist, alles auf der Festplatte zu überschreiben, einschließlich des Betriebssystems und aller Daten auf der Festplatte.
Es gibt jedoch einige weitere Vorteile dieser Art von Datenlöschprogrammen. Da diese destruktiven Datenlöschprogramme völlig unabhängig von Betriebssystem und Dateisystem arbeiten und direkt auf die Oberfläche der Festplatte schreiben, sind sie angemessen schneller als die nicht-destruktiven Datenlöscher.
Auch wenn logisch fehlerhafte Sektoren auf der Festplatte aufgrund illegaler Speicherung einiger zufälliger Daten erstellt werden, werden diese logisch fehlerhaften Sektoren ebenfalls vollständig mit den Daten der Festplatte gelöscht.
Als nächstes wurde die Codierung für ein destruktives Datenlöschprogramm angegeben. Das Programm wurde so geschrieben, dass es auch große Festplatten unterstützt. Das Programm löscht die Daten der zweiten physischen Festplatte, die mit dem Computer verbunden ist.
///// Codierung für ein destruktives Datenlöschprogramm \\\\\
#include<stdio.h>
#include<dos.h>
/* Von der getdrivegeometry-Funktion zu verwendende Struktur unter Verwendung von INT 13H-Erweiterung, Funktionsnummer 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 */
} ;
/* Struktur des Plattenadresspaketformats, das von der Writeabsolutesectors-Funktion verwendet werden soll */
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 */
} ;
///// Funktion zum Abrufen von Antriebsparametern \\\\\
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 ) ;
/* Rufen Sie die angegebene Funktionsnummer der INT 13H-Erweiterung mit Segmentregisterwerten auf */
int86x ( 0x13, &i, &o, &s ) ;
printf("\n Head = %lu, Sectors Per Track = %lu, Cylinder =
%lu\n",
g.heads,g.spt,g.cyl);
/* Wenn die Funktion zum Abrufen der Antriebsgeometrie fehlschlägt, Fehlermeldung anzeigen und beenden */
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();
/* Wenn Gesamtnr. der angeschlossenen Festplatten ist weniger als zwei. Fehlermeldung anzeigen und beenden. */
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);
///// Erst bestätigen, dann fortfahren \\\\\
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);
}
///// Nachricht anzeigen, wenn abgeschlossen \\\\\
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();
}
//// Funktion zum Schreiben absoluter Sektoren \\\\
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 */
/* für Datenpuffer */
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 */
/* Rufen Sie die angegebene Funktion von INT 13H mit Segmentregisterwerten auf */
int86x ( 0x13, &i, &o, &s ) ;
if ( o.x.cflag==1)
return 0 ; //failure
else
return 1 ; // success
}
Anmerkungen zur Codierung:
Die Strukturgeometrie wird von der getdrivegeometry-Funktion unter Verwendung der INT 13H-Erweiterung, Funktionsnummer 0x48 verwendet, um die verschiedenen Parameter der Platte zu erhalten.
Die Struktur diskaddrpacket ist für das Plattenadresspaketformat, das von der Funktion writeabsolutesectors verwendet werden soll.
Die Funktion getdrivegeometry (int drive) dient zum Abrufen von Laufwerksparametern des Laufwerks mit der angegebenen physischen Laufwerksnummer. Puffer [61440] ist der Datenpuffer von 61440 Bytes, was 120 Sektoren entspricht.
(char) peekb(0x0040, 0x0075) wird verwendet, um die Anzahl der an den Computer angeschlossenen Festplatten zu finden, die am Speicherort gespeichert sind, der durch Segment 0040H:Offset 0075H dargestellt wird. Wenn die Gesamtzahl der angeschlossenen Festplatten kleiner als zwei ist, Fehlermeldung anzeigen und beenden.
Die Funktion writeabsolutesectors ( 0x81, loop, 120, buffer ) wird verwendet, um die Daten des Datenpuffers auf 120 Sektoren gleichzeitig zu schreiben, beginnend mit der durch loop angegebenen absoluten Sektornummer.
Ich habe ‘\0’ (NULL-Zeichen, ASCII-Code 0) zum Schreiben auf die Sektoren zum Überschreiben der Daten. Sie können jedoch beliebige Zeichen verwenden, um die Daten zu überschreiben.
Eine detaillierte Beschreibung der Funktionen writeabsolutesectors und getdrivegeometry finden Sie in den Kapiteln weiter oben in diesem Buch.
Löschen des Datenbereichs einer bestimmten Datei
Wir haben über die Datenlöschprogramme gesprochen, die die Daten des nicht zugeordneten Speicherplatzes der Festplatte löschen oder die gesamte Festplatte löschen. Wenn der Benutzer jedoch bereit ist, die Daten jedes Mal zu löschen, wenn er die Daten löscht, kann es zeitaufwändig sein, den gesamten nicht zugeordneten Speicherplatz der Festplatte zu löschen.
Wir benötigen diese Art von Datenlöschprogrammen, um den Datenbereich zu löschen, der nur von dieser bestimmten Datei belegt ist. Dazu holen wir uns die Hilfe von FAT- und Root-Verzeichniseinträgen, um den Datenbereich zu finden, der von diesen bestimmten Dateien belegt ist.
Selbst im Falle einer Diskette, wenn die Daten nicht fragmentiert sind, können wir dies nur mit Hilfe der Root-Verzeichnisinformationen tun. Die folgende Tabelle zeigt die Informationen, die von einem Stammverzeichniseintrag mit 32 Byte für jede Datei gespeichert werden:
Wie wir im Inhaltsverzeichnis des Stammverzeichniseintrags sehen, sind wir in der Lage, den Anfangs- und Endcluster der Dateien zu finden. Das erste Byte des Dateinamens kann auch einige wichtige Informationen über die Datei enthalten. Die von diesem Byte bereitgestellten Informationen können eine der folgenden sein:
Lassen Sie uns diese Informationen ausprobieren, um die Daten einer beliebigen Datei zu löschen, die in 1,44 MB, 3 ½ Zoll-Diskette, mit Hilfe von Root-Verzeichnisinformationen. Unter der Annahme, dass die Daten auf der Diskette nicht fragmentiert sind, löscht das als nächstes angegebene Programm die Daten der angegebenen Datei aus ihrem Datenbereich:
/* Programm zum Löschen des Datenbereichs der angegebenen Datei auf der Diskette */
#include<stdio.h>
#include<dos.h>
///// Struktur zum Lesen von 32 Byte Dateieintrag im Stammverzeichnis \\\\\
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 */
};
/* Dies sollte genommen werden, um alle Root-Verzeichniseinträge zu lesen */
//struct root entry[224];
/* Struktur zum Lesen aller 16 Dateieinträge in einem Sektor des Stammverzeichnisses */
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);
}
/* Anzeige der Dateiinformationen nach dem Lesen aus dem Stammverzeichnis */
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);
}
//// Benutzereingabe abrufen, um die Datei zu löschen \\\\
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);
}
///// Erst bestätigen, dann fortfahren \\\\\\
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);
}
///// Berechnen Sie die Größe der Datei in Sektoren \\\\\
num_sectors = one.entry[i].file_size/512;
if((one.entry[i].file_size%512)>0)
{
num_sectors = num_sectors+1;
}
/* Datenpuffer von 512 Bytes mit 512 NULL-Zeichen */
for(j=0;j<512;j++)
{
wipe_buf[j] = '\0';
}
///// Startsektor der Datei \\\\\
j= one.entry[i].starting_cluster+31;
/* Löschen Sie den Datenbereich bis zum Ende der Sektoren der Datei */
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 */
///// Schreiben Sie obige Informationen in das Stammverzeichnis \\\\\\
result= abswrite(0x00, 1, 19, &one);
if (result != 0)
{
perror("Error in Reading Sector, Press any key to
Exit...");
getch();
exit(1);
}
}
Anmerkungen zur Logik und Kodierung des Programms:
Die Struktur root wird verwendet, um 32 Bytes des Dateieintrags im Root-Verzeichnis zu lesen, und die Struktur one_root_sector liest alle 16 Dateieinträge in einem Sektor des Root-Verzeichnisses.
Wenn Sie alle Sektoren der Root-Verzeichnisinformationen lesen möchten, sollten Sie sie als struct root entry[224] nehmen; jedoch habe ich das Programm geschrieben, um die 16 Einträge von nur einem Sektor des Stammverzeichnisses zu analysieren.
Der Startsektor der Datei wurde wie folgt berechnet:
j= one.entry[i].starting_cluster+31;
Dies geschieht, weil der Datenbereich der 1,44 MB, 3 ½ Zoll Diskette beginnt nach den ersten 32 Sektoren der Diskette. Und bei der Diskette mit angegebener Kapazität besteht ein Cluster aus einem Sektor.
Die folgende Tabelle zeigt die logische Zuordnung von 1,44 MB, 3½ Zoll Diskette:
The out put of the program is displayed as follows:
Hier haben wir die Daten der Datei PARTBOOT.C gelöscht und gelöscht. Wenn wir den Inhalt der Diskette mit dem DIR-Befehl sehen, wird die Datei PARTBOOT.C dort nicht angezeigt. Wenn wir das Programm weiter ausführen, wird der Eintrag der gelöschten Datei wie folgt angezeigt:
Hier ist das Zeichen “” (0xE5) bedeutet, dass die Datei gelöscht wurde. (siehe Tabelle für das erste Zeichen des Dateinamens).
Wenn Sie dasselbe Programm für Festplattenlaufwerke schreiben möchten, müssen Sie auch die FAT mit dem Stammverzeichnis verwenden, um die Informationen des Datenbereichs einer beliebigen Datei zu erhalten.
Dies liegt daran, dass die Rate fragmentierter Daten auf den Festplatten mit der Zeit zunimmt, wenn ältere Dateien gelöscht und neue Dateien erstellt werden. Dann ist es nicht erforderlich, dass alle Datencluster irgendeiner Datei im Laufwerk nacheinander kontinuierlich im Datenbereich bleiben. Durch den Zugriff auf FAT können Sie auf alle diese Cluster zugreifen.
Seite Geändert am: 08/03/2022
Zuhause