Kapitel – 15
PROGRAMMIERUNG FÜR DATENREINIGER
Einführung
Wir haben bereits besprochen, dass beim Löschen einer Datei von einer Festplatte die Informationen nicht vollständig von der Festplatte gelöscht werden, sondern als zum Schreiben neuer Daten verfügbar markiert werden.
Wenn wir eine Platte formatieren, werden zwar alle Informationen zu den Dateien und Verzeichnissen der Platte, wie etwa FAT- und Stammverzeichniseinträge, gelöscht, der Datenbereich bleibt jedoch unverändert und es wird nichts aus dem Datenbereich der Platte gelöscht. Vom Betriebssystem gelöschte oder formatierte Daten verbleiben unverändert im Datenbereich und können mit einigen Datenwiederherstellungsbemühungen und Datenwiederherstellungssoftware wiederhergestellt werden.
Wenn Daten vollständig von der Festplatte gelöscht werden müssen, ist daher ein Programm erforderlich, das die Daten vollständig von der Festplatte löscht. Hierzu genügt es nicht, einfach Dateien zu löschen oder den Datenträger lediglich zu formatieren, es müssen die Daten auf dem Datenträger durch andere Daten überschrieben werden.
Programme, mit denen Daten vollständig von einer Festplatte gelöscht werden, heißen Datenlöschprogramme. Diese Programme schreiben zufällige Zeichen in den Datenbereich, um die Daten zu überschreiben und alle zuvor auf der Festplatte gespeicherten Informationen zu löschen.
Wenn Daten vollständig unwiederbringlich sind
Zum Löschen von Daten muss der Datenbereich auf der Platte mit anderen Daten überschrieben werden, doch damit ist das Problem noch nicht beendet. Um die Sache noch komplizierter zu machen, müssen die Daten aufgrund der Eigenschaft von Magnetplatten, sich überschriebene Daten zu merken, auch mehrmals mit zufälligen Datensequenzen überschrieben werden, so dass sie selbst mit hochentwickelten Datenwiederherstellungstools nicht wiederhergestellt werden können.
Dies liegt daran, dass heute Technologien verfügbar sind, die eine Datenwiederherstellung auch nach dem Einsatz einfacher Datenlöschtools ermöglichen.
Einige Datenlöschprodukte überschreiben Daten mit binären Nullen und binären Einsen. Das Schreiben einer Reihe von binären Nullen und binären Einsen bietet den tiefgreifendsten Umschreibeffekt, da diese Werte jeweils die minimalen und maximalen magnetischen Werte sind.
Dies ist zwar die Theorie des idealen Datenlöschprogramms, im Allgemeinen reicht jedoch das Überschreiben der Daten mit einem zufälligen ASCII-Zeichen aus. Der Grund hierfür ist, dass die Daten einer Organisation nicht mithilfe hochentwickelter Wiederherstellungstools und -technologien im Rahmen einer routinemäßigen Datenwiederherstellung wiederhergestellt werden können, da diese Technologien sehr teuer sind und selbst eine einmalige Wiederherstellung Millionen kostet. Darüber hinaus sind diese Technologien nur in wenigen Ländern der Welt verfügbar.
Wir besprechen nur das einfache Überschreiben von Daten, um Daten von der Festplatte zu löschen. Sie können dieselben Programme jedoch mit geringem Aufwand weiter modifizieren, um nur zufällige Zeichen zu schreiben. Die auf diese Weise gelöschten Daten können auch mit keiner Datenwiederherstellungssoftware wiederhergestellt werden.
Warum ist die Datenlöschung so wichtig?
Wenn wir Methoden zur Datenwiederherstellung besprechen, versichern wir dem Benutzer, dass die Daten mit einigen allgemeinen oder speziellen Datenwiederherstellungsbemühungen wiederhergestellt werden können. Aber die Datenwiederherstellung ist nicht immer eine von jedem gewünschte und erwartete Funktion.
Viele Personen oder Organisationen sind jederzeit bereit, die Daten auf ihrer Festplatte so zu löschen, dass sie auf keine Weise wiederhergestellt werden können. In solchen Fällen kann die Festplatte zuvor sehr vertrauliche Daten enthalten haben, die, wenn sie in die falschen Hände geraten, der Organisation oder dem Benutzer aufgrund der unsachgemäßen Verwendung der Informationen Schaden zufügen könnten.
Wie wir wissen, steigt der Bedarf an immer mehr Festplattenspeicher täglich. Daher werden in nahezu allen Unternehmen jedes Jahr in großem Umfang alte Laufwerke mit geringer Kapazität durch neue Laufwerke mit hoher Kapazität ersetzt. Wenn diese alten Festplatten in die falschen Hände geraten, könnte dies für diese Organisation zu einem sehr ernsten Problem werden.
Einem am 16. Januar 2003 auf CNET News.com veröffentlichten Nachrichtenbericht zufolge kauften die MIT-Studenten Simon Garfinkel und Abby Shelat im Internet und bei anderen Gebrauchtplattenhändlern alte Festplatten für Forschungszwecke, um Zugriff auf riesige Mengen persönlicher Daten zu erhalten, die sonst niemand löscht.
Nachdem sie 158 Laufwerke für rund 1.000 US-Dollar gekauft hatten, gelang es ihnen, über 5.000 Kreditkartennummern, Krankenakten, detaillierte persönliche und geschäftliche Finanzinformationen sowie mehrere Gigabyte an E-Mails, Quellcodes und anderen Informationen zu sammeln.
Diese beiden Studenten haben ihre Erkenntnisse in einem Bericht mit dem Titel „Remembrance of Data Passed: A Study of Disk Sanitation“ zusammengefasst, der in der Februarausgabe von IEEE Security and Privacy veröffentlicht wurde.
Die wichtigsten Erkenntnisse der Untersuchung bestehen darin, dass der Markt für gebrauchte Festplatten voller persönlicher Informationen ist, wodurch es für böswillige Käufer sehr leicht wird, die Identität einer anderen Person anzunehmen.
Schreiben eines Programms zum zerstörungsfreien Löschen von Daten
Der zerstörungsfreie Datenlöscher ist eine Art Datenlöschprogramm, mit dem wir den gesamten „nicht zugewiesenen Speicherplatz“ des Datenträgervolumens löschen können, ohne die auf der Festplatte gespeicherten Daten in irgendeiner Weise zu beschädigen.
Der Einsatzbereich eines solchen Datenlöschers liegt in den Fällen, in denen Sie den gesamten nicht zugeordneten Speicherplatz des Datenträgervolumes löschen möchten, während die im Volume gespeicherten zugeordneten Daten unberührt bleiben sollen. Diese Art von Datenlöschprogramm löscht auch den Datenbereich gelöschter Dateien.
Nachfolgend sehen Sie den Programmcode für ein zerstörungsfreies Datenlöschprogramm:
///// Programm für einen zerstörungsfreien Datenlöscher \\\\\
#include <stdio.h>
unsigned int file_num=0; /* Liefert die Dateinummer
Während der automatischen Erstellung
von temporären Datendateien */
float status=0; /* Wie viel Speicherplatz ist
noch Geschrieben */
static char dbuf[40000]; /* Zu schreibender Datenpuffer
Temporäre Dateien mit */
char file_extension[5]=".ptt";/* Eindeutige Erweiterungen für
Temporäre Dateien */
char temp[5]; /* Dateinummer konvertiert in
Zeichenfolge */
char filename[40]; /* Temporärer Dateiname */
void main()
{
vorzeichenlose Ganzzahl i=0;
clrscr();
während(i<40000)
{
dbuf[i] = ' ';
ich++;
}
gotoxy(10,14);cprintf("MB noch geschrieben...");
während(1)
{
/* Logik zum automatischen Erstellen temporärer Dateien mit eindeutigem Namen */
strcpy(Dateiname,"TTPT");
itoa(Dateinummer,Temp,10);
strcat(Dateiname,temp);
strcat(Dateiname,Dateierweiterung);
Dateinummer++;
write_to_temp(Dateiname);
}
} //// Ende von Main \\\\
///// Funktion zum Schreiben der Daten in die temporäre Datei \\\\\
write_to_temp(char *Dateiname)
{
vorzeichenlose Ganzzahl i, Anzahl=1;
Float-Pufferstatus = 0.
DATEI *tt;
wenn((tt=fopen(Dateiname,"wb"))==NULL)
{
fclose(tt);
printf("\n Beim Erstellen der temporären Datei ist ein Fehler aufgetreten
Datei, ");
printf("\n Temporäre Dateien nach KEY BOARD entfernen
SCHLAG");
getch();
remove_temp_file();/* Alle temporären Dateien entfernen */
}
während(1)
{
für (i = 0; i < 50; i++)
{
fprintf(tt,"%s",dbuf);
}
buf_status = (Float)((40000*50*Anzahl)/512);
Status = Status + (40000 * 50);
zählen++;
gotoxy(10,14);
cprintf("%.0f",(float)(status/1000000));
wenn(kbhit())
{
fclose(tt);
printf("\n Bitte temporäre Dateien entfernen
Warten...");
entferne_temp_file();
}
wenn(buf_status>=10000)
{
fclose(tt);
zurückkehren;
}
}
}
/* Funktion zum automatischen Löschen der temporären Dateien */
remove_temp_file()
{
} i = 0;
für (i = 0; i <= Dateinummer; i++)
{
strcpy(Dateiname,"TTPT");
dies(i,temp,10);
strcat(Dateiname,temp);
strcat(Dateiname,Dateierweiterung);
entfernen(Dateiname);
}
Ausgang (1);
gebe 0 zurück;
}
Kommentare zur Logik und zur Codierung des Programms:
In diesem Programm befolgen wir grundsätzlich die folgenden zwei Schritte, 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 darin enthaltenen Daten, bis das Datenträgervolumen mit diesen temporären Datendateien voll ist. Dadurch wird der gesamte nicht zugeordnete Datenbereich des logischen Laufwerks mit den Daten der temporären Dateien belegt und alle nicht zugeordneten Daten werden überschrieben.
Zu diesem Zweck habe ich die Namen der temporären Dateien im Format TTPTxxxx.PTT gewählt, d. h. die ersten vier Zeichen der temporären Dateien sind TTPT und die Dateierweiterung 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 Sektoren entspricht. Sie können sie jedoch nach Ihren Wünschen definieren. Ich habe das Leerzeichen „ “ (ASCII-Zeichen 32) gewählt, 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 mit temporären Dateien voll ist, bedeutet dies, dass der gesamte nicht zugeordnete Datenbereich nun überschrieben ist. Jetzt werden alle vom Programm erstellten temporären Dateien automatisch entfernt. Auf diese Weise wird der nicht zugeordnete Speicherplatz gelöscht.
Im Code des Programms speichert das Zeichenarray „Dateiname“ den Dateinamen, um automatisch temporäre Dateien mit unterschiedlichen Namen zu generieren.
Die Funktion write_to_temp(Dateiname); füllt die temporäre Datei mithilfe des 40.000 Byte großen Datenpuffers dbuf mit bis zu 11.718 Sektoren (da in der angegebenen Puffergruppe keine 10.000 Sektoren vorkommen). Der Datenpuffer wird jeweils 50 Mal beschrieben, um das Schreiben zu beschleunigen.
Die temporären Dateien werden erstellt, bis das Datenträgervolume voll ist und ein Fehler bei der Dateierstellung auftritt. Die Funktion remove_temp_file() entfernt alle vom Programm erstellten temporären Dateien.
Auf diese Weise wird der gesamte nicht zugeordnete Speicherplatz gelöscht, ohne die Daten auf dem Datenträger zu beschädigen.
Programm für Destructive Data Wiper schreiben:
Destruktive Datenlöschprogramme sind solche, die direkt auf die Oberfläche der Festplatte schreiben. Diese Art von Datenlöschprogrammen arbeitet auf einer niedrigeren Ebene als das Dateisystem und das Betriebssystem, was bedeutet, dass alle Daten und andere logische Informationen, einschließlich Betriebssystem, Dateisysteme, Verzeichniseinträge und alles, was auf die Festplatte geschrieben wurde, gelöscht werden.
Diese Datenlöschprogramme löschen direkt die Sektoren auf der Oberfläche der Festplatte und vernichten 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 Art von Löschprogrammen wird in solchen Fällen bevorzugt, in denen der Benutzer alles auf der Festplatte überschreiben möchte, einschließlich des Betriebssystems und aller Daten auf der Festplatte.
Allerdings bieten diese Art von Datenlöschprogrammen noch weitere Vorteile. 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 wesentlich schneller als die nicht-destruktiven Datenlöschprogramme.
Wenn aufgrund der illegalen Speicherung beliebiger Daten logisch fehlerhafte Sektoren auf der Festplatte erstellt werden, werden diese logisch fehlerhaften Sektoren zusammen mit den Daten auf der Festplatte ebenfalls vollständig gelöscht.
Als nächstes wird der Code für ein Programm zum destruktiven Löschen von Daten 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 an den Computer angeschlossen ist.
///// Codierung für ein destruktives Datenlöschprogramm \\\\\
#include<stdio.h>
#include<dos.h>
/* Von der Funktion getdrivegeometry zu verwendende Struktur unter Verwendung der Erweiterung INT 13H, Funktionsnummer 0x48. */
Strukturgeometrie
{
unsigned int size ; /* (Aufruf) Größe des Puffers */
unsigned int flags ; /* Informationsflags */
unsigned long cyl ; /* Anzahl der physikalischen Zylinder auf
Fahren */
unsigned long heads ;/* Anzahl der physischen Köpfe auf
Fahren */
unsigned long spt ; /* Anzahl der physischen Sektoren pro
Schiene */
unsigned long sectores[2] ; /* Gesamtzahl der
Sektoren auf Laufwerk */
unsigned int bps; /* Bytes pro Sektor */
} ;
/* Struktur des Disk-Adresspaketformats, zu verwenden durch die Funktion writeabsolutesectors */
Struktur Diskaddrpacket
{
char packetsize ; /* Größe des Pakets,
im Allgemeinen 10H */
char reserviert; /* Reserviert (0) */
int blockcount ; /* Anzahl der zu
Überweisen */
char far *bufferaddress ; /* zu übertragende Adresse
Puffer */
unsigned long blocknumber[2] ; /* Startabsoluter Wert
Blocknummer */
} ;
///// Funktion zum Abrufen der Antriebsparameter \\\\\
unsigned long getdrivegeometry (int-Laufwerk)
{
Gewerkschaftsreglemente i, o;
Struktur SREGS s;
Strukturgeometrie g = { 26, 0, 0, 0, 0, 0, 0, 0 } ;
ihah = 0x48; /* Funktion Nummer 0x48 von INT 13H
Erweiterungen */
ihdl = Laufwerk; /* Laufwerksnummer */
ixsi = 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 Kopf = %lu, Sektoren pro Spur = %lu, Zylinder =
%lu\n",
g.Köpfe, g.Spt, g.Zyl.);
/* Wenn die Funktion „Laufwerksgeometrie abrufen“ fehlschlägt, Fehlermeldung anzeigen und beenden */
wenn(g.spt==0)
{
printf("\n Die Funktion „Laufwerksgeometrie abrufen“ schlägt fehl …");
printf("\n Erweiterungen werden nicht unterstützt, drücken Sie eine beliebige Taste, um
Ausfahrt...");
getch();
Ausgang (1);
}
return *g.sectors; /* Gibt die Anzahl der
Sektoren auf Laufwerk */
}
void main()
{
vorzeichenlose lange Schleife=0, Sektoren_in_HDD2=0;
unsigned char buffer[61440]; /* Datenpuffer von 61440
Bytes Äquivalent zu
120 Sektoren */
vorzeichenloses langes i=0;
Zeichenauswahl;
clrscr();
/* Wenn die Gesamtzahl der angeschlossenen Festplatten weniger als zwei beträgt, wird eine Fehlermeldung angezeigt und das Programm wird beendet. */
wenn(((char)peekb(0x0040, 0x0075))<2)
{
printf("\n\n Sie müssen mindestens zwei Festplatten haben
Zum Ausführen an Ihren Computer angeschlossen");
printf("\n Programm. Dieses Programm wurde entwickelt
zum Löschen der Daten der zweiten Festplatte.");
printf("\n Zum Beenden eine beliebige Taste drücken... ");
getch();
Ausgang (1);
}
Sektoren_auf_HDD2 = getdrivegeometry (0x81);
printf(" Gesamtzahl der Sektoren auf der zweiten Festplatte =
%lu\n\n",
Sektoren_auf_HDD2);
///// Erst bestätigen, dann fortfahren \\\\\
printf("\n Es ist ein Datenlöschprogramm und schreibt auf
die Oberfläche der Scheibe,");
printf("\n Nach dem Ausführen dieses Programms können Daten nicht
von keiner Software wiederhergestellt werden kann");
printf("\n Alle Daten auf der zweiten Festplatte werden
verloren !!!");
printf("\n Drücken Sie \'Y\' um fortzufahren, sonst eine beliebige Taste um
Ausfahrt... ");
Wahl = getche();
Schalter (Auswahl)
{
Fall 'y':
Fall 'Y':
brechen;
Standard:
Ausfahrt (0);
}
gotoxy(10,15);cprintf("Initialisierung, bitte warten …");
für (i = 0; i < 61440; i++)
{
Puffer[i]='\0';
}
gotoxy(10,15);cprintf(" ");
gotoxy(10,15);
printf("Derzeit wird der absolute Sektor gelöscht: ");
für (Schleife = 0; Schleife <= Sektoren auf Festplatte2; Schleife = Schleife + 120)
{
writeabsolutesectors (0x81, Schleife, 120, Puffer);
gotoxy(44,15); printf("%ld",Schleife);
wenn(kbhit())
{
Ausfahrt (0);
}
///// Meldung anzeigen, wenn abgeschlossen \\\\\
printf("\n\n Die Datenlöschung ist nun abgeschlossen, alle Daten in
Die zweite Festplatte ist jetzt");
printf("\n Komplett gelöscht. Zum Beenden eine beliebige Taste drücken...");
getch();
}
//// Funktion zum Schreiben absoluter Sektoren \\\\
int writeabsolutesectors (int Laufwerk, unsigned long Sektornummer, int AnzahlSektoren, void *Puffer)
{
Gewerkschaftsreglemente i, o;
Struktur SREGS s;
Struktur Diskaddrpacket pp;
pp.packetsize = 16; /* Paketgröße = 10H */
pp.reserved = 0 ; /* Reserviert = 0 */
pp.blockcount = numofsectors ;/* Anzahl der zu
geschrieben werden */
/* für Datenpuffer */
pp.bufferaddress = (char far*) MK_FP ( FP_SEG((void far*)buffer), FP_OFF((void far*)buffer));
pp.blocknumber[0] = sectornumber ; /* Sektornummer
geschrieben werden*/
pp.blocknumber[1] = 0 ; /* Blocknummer = 0 */
ihah = 0x43; /* Funktionsnummer */
ihal = 0x00; /* Flags schreiben */
ihdl = Laufwerk; /* Physisches Laufwerk
Nummer */
ixsi = FP_OFF ( (void far*)&pp ) ; /* ds:si für
Pufferparameter */
s.ds = FP_SEG ( (void far*)&pp ) ; /* ds:say für
Pufferparameter */
/* Rufe die angegebene Funktion von INT 13H mit Segmentregisterwerten auf */
int86x (0x13, &i, &o, &s);
wenn (oxcflag==1)
returniere 0; //Fehler
anders
return 1; // Erfolg
}
Anmerkungen zur Kodierung:
Die Strukturgeometrie wird von der Funktion getdrivegeometry mit der Erweiterung INT 13H, Funktionsnummer 0x48, verwendet, um die verschiedenen Parameter der Festplatte abzurufen.
Die Struktur „diskaddrpacket“ ist für das Disk-Adresspaketformat bestimmt und soll von der Funktion „writeabsolutesectors“ verwendet werden.
Die Funktion getdrivegeometry (int drive) dient zum Abrufen der Laufwerksparameter der Festplatte mit der angegebenen physischen Laufwerksnummer. buffer [61440] ist der Datenpuffer von 61440 Bytes, entsprechend 120 Sektoren.
(char) peekb(0x0040, 0x0075) wird verwendet, um die Anzahl der an den Computer angeschlossenen Festplatten zu ermitteln, die an der Speicherposition gespeichert sind, die durch das Segment 0040H:Offset 0075H dargestellt wird. Wenn die Gesamtzahl der angeschlossenen Festplatten kleiner als zwei ist, wird eine Fehlermeldung angezeigt und das System beendet.
Die Funktion writeabsolutesectors (0x81, Schleife, 120, Puffer) wird verwendet, um die Daten des Datenpuffers beginnend mit der durch die Schleife angegebenen absoluten Sektornummer in jeweils 120 Sektoren zu schreiben.
Ich habe zum Überschreiben der Daten in die Sektoren '\0' (NULL-Zeichen, ASCII-Code 0) gewählt. Sie können die Daten jedoch auch mit beliebigen anderen Zeichen überschreiben.
Eine detaillierte Beschreibung der Funktionen writeabsolutesectors und getdrivegeometry finden Sie in den früheren Kapiteln dieses Buches.
Datenbereich einer bestimmten Datei löschen
Wir haben über Datenlöschprogramme gesprochen, die die Daten des nicht zugeordneten Speicherplatzes der Festplatte 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 ein zeitaufwändiger Vorgang 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 erhalten wir Hilfe von FAT- und Stammverzeichniseinträgen, um den Datenbereich zu finden, der von diesen bestimmten Dateien belegt ist
Selbst bei Disketten können wir die Daten nur mithilfe der Informationen des Stammverzeichnisses fragmentieren, wenn sie nicht fragmentiert sind. Die folgende Tabelle zeigt die Informationen, die in einem Stammverzeichniseintrag mit 32 Bytes für jede Datei gespeichert werden:
Wie wir im Inhaltsverzeichnis des Stammverzeichniseintrags sehen, können wir den Start- und Endcluster der Dateien 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:
Versuchen wir, mit Hilfe der Stammverzeichnisinformationen die Daten einer beliebigen Datei zu löschen, die auf einer 1,44 MB großen, 3 ½ Zoll großen Diskette gespeichert ist. Vorausgesetzt, die Daten auf der Diskette sind nicht fragmentiert, löscht das folgende 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 Bytes des Dateieintrags im Stammverzeichnis \\\\\
Strukturwurzel
{
unsigned char filename[8]; /* Dateiname Eintrag von
8 Bytes */
unsigned char extension[3]; /* Dateierweiterung von
3 Bytes */
unsigned char attribute; /* Dateiattribut-Byte */
unsigned char reserved[10]; /* Reservierte Bytes 10 */
unsigned int time; /* Zeit, 2 Bytes */
unsigned int date; /* Datum, 2 Bytes */
unsigned int starting_cluster;/* Startcluster der Datei,
2 Bytes */
unsigned long file_size; /* Dateigröße in Bytes,
4 Bytes */
};
/* Dies sollte verwendet werden, um alle Stammverzeichniseinträge zu lesen */
//Struktur root entry[224];
/* Struktur zum Lesen aller 16 Dateieinträge in einem Sektor des Stammverzeichnisses */
Struktur one_root_sector
{
Struktur root entry[16];
};
Struktur one_root_sector one;
void main()
{
int Ergebnis, i, Anz. Sektoren, j;
char wipe_buf[512]; /* Datenpuffer, der zum Löschen verwendet werden soll
Datenbereich der Datei auslesen */
clrscr();
Ergebnis = absread (0x00, 1, 19, &one); /* Absoluten Sektor lesen
19 (Erster Sektor des Stammverzeichnisses) */
wenn (Ergebnis != 0)
{
perror("Fehler beim Lesen des Sektors. Drücken Sie eine beliebige Taste, um
Ausfahrt...");
getch();
Ausgang (1);
}
/* Dateiinformationen nach dem Lesen aus dem Stammverzeichnis anzeigen */
printf(" DATEI NR. DATEINAME ERWEITERUNG START CLUSTER
DATEIGRÖSSE \n\n");
für (i = 1; i < 16; i++)
{
druckenf("\n %5d %8.8s %3.3s %5u %10lu ",
i, ein.Eintrag[i].Dateiname, ein.Eintrag[i].Erweiterung,
ein.Eintrag[i].Startcluster, ein.Eintrag[i].Dateigröße);
}
//// Benutzereingabe zum Löschen der Datei einholen \\\\
printf("\n\n Geben Sie die Dateinummer ein, die Sie löschen möchten und
Vollständig auslöschen");
scanf("%d", &i);
wenn(i<1 || i>15)
{
printf(" \"%d\" ist eine ungültige Auswahl..., Drücken Sie eine beliebige
Taste zum Beenden...", i);
getch();
Ausgang (1);
}
///// Erst bestätigen, dann fortfahren \\\\\\
printf("\n Du bist kurz vor dem Auslöschen,
Die Datei \"%.8s.%s\"",
ein.Eintrag[i].Dateiname,
eins.eintrag[i].erweiterung);
printf("\n Möchten Sie fortfahren...(J/N) ");
Schalter(getche())
{
Fall 'y':
Fall 'Y':
brechen;
Standard:
Ausfahrt (0);
}
///// Berechnen Sie die Größe der Datei in Sektoren \\\\\
Anzahl_Sektoren = ein.Eintrag[i].Dateigröße/512;
wenn((ein.Eintrag[i].Dateigröße%512)>0)
{
Anzahl_Sektoren = Anzahl_Sektoren+1;
}
/* Datenpuffer von 512 Bytes mit 512 NULL-Zeichen */
für (j=0;j<512;j++)
{
wipe_buf[j] = '\0';
}
///// Startsektor der Datei \\\\\
j= ein.Eintrag[i].Startcluster+31;
/* Datenbereich bis zum Ende der Dateisektoren löschen */
Platz(j!=(one.entry[i].starting_cluster +
Anzahl_Sektoren+31) )
{
wenn((abswrite(0x00, 1, j, &wipe_buf))!=0)
{
printf("\n Fehler beim Schreiben in die Festplattensektoren");
erhalten();
Ausgabe(0);
}
}
}
printf("\n\n Datei \"%.8s.%.3s\" gelöscht !!!",
ein.Eintrag[i].Dateiname,
eins.eintrag[i].erweiterung);
ein.Eintrag[i].Attribut = 0; /* Dateiattribut festlegen
auf 0 */
ein.Eintrag[i].Zeit = 0; /* Zeitinformationen löschen
Datei */
ein.Eintrag[i].Datum = 0; /* Datumsinformationen löschen
Datei */
ein.Eintrag[i].Startcluster = 0; /* Setze den anfänglichen Cluster auf 0
*/
ein.Eintrag[i].Dateigröße = 0; /* Dateigröße auf 0 setzen */
eins.eintrag[i].dateiname[0]=0xE5; /* Fernbedienung angeben
Dateistatus in Datei */
///// Schreiben Sie die obigen Informationen in das Stammverzeichnis \\\\\\
Ergebnis = abswrite(0x00, 1, 19, &eins);
wenn (Ergebnis != 0)
{
perror("Fehler beim Lesen des Sektors, drücken Sie eine beliebige Taste, um
Ausfahrt...");
erhalten();
Ausgabe(1);
}
}
Kommentare zur Logik und Codierung des Programms:
Die Root-Struktur wird zum Lesen von 32 Bytes eines Dateieintrags im Root-Verzeichnis verwendet, und die One_Root_Sector-Struktur liest alle 16 Dateieinträge in einem Sektor des Root-Verzeichnisses.
Wenn Sie alle Sektoren der Stammverzeichnisinformationen lesen möchten, sollten Sie diese als struct root[224]-Eintrag nehmen; Ich habe jedoch ein Programm geschrieben, um 16 Datensätze von nur einem Sektor des Stammverzeichnisses zu analysieren.
Der Startsektor der Datei wird wie folgt berechnet:
j= ein.Datensatz[i].Initialcluster+31;
Dies liegt daran, dass der Datenbereich einer 1,44 MB großen 3 ½ Zoll-Diskette nach den ersten 32 Sektoren der Diskette beginnt. Und auf einer Diskette der angegebenen Kapazität entspricht ein Cluster einem Sektor.
Die folgende Tabelle zeigt die logische Zuordnung einer 1,44 MB großen 3½-Zoll-Diskette:
Das Ergebnis des Programms wird wie folgt angezeigt:
Hier haben wir die Daten der Datei PARTBOOT.C gelöscht und entfernt. Wenn wir den Inhalt der Diskette mit dem Befehl DIR anzeigen, wird die Datei PARTBOOT.C dort nicht angezeigt. Bei der weiteren Ausführung des Programms wird der Eintrag für die gelöschte Datei wie folgt angezeigt:
Dabei bedeutet das Symbol „“ (0xE5), dass die Datei gelöscht wurde. (das erste Zeichen des Dateinamens finden Sie in der Tabelle).
Wenn Sie dasselbe Programm für die Festplatte schreiben möchten, müssen Sie auch FAT mit Stammverzeichnis verwenden, um Informationen zum Datenbereich einer beliebigen Datei zu erhalten.
Dies liegt daran, dass die Datenfragmentierung auf Festplatten mit der Zeit zunimmt, da alte Dateien gelöscht und neue erstellt werden. Dann ist es nicht mehr erforderlich, dass alle Datencluster einer Datei auf der Platte hintereinander und zusammenhängend im Datenbereich liegen. Durch Zugriff auf FAT können Sie auf alle diese Cluster zugreifen.
