Datei sicher löschen

[Luckie]

In diesem Thread http://www.delphipraxis.net/internal...cher+l%F6schen habe ich folgende zwei Codes zum sicheren Löschen einer Datei gefunden:
shmia:

Delphi-Quellcode:

procedure ShredderFile(const filename:string);
const
  Fillchars: array[0..5] of char = (Char($00), Char($FF), Char($00), Char($F0), Char($0F), Char($00));
  BLOCK_SIZE = 8096;
var
   fs : TStream;
   buffer : String;
   i, j : Integer;
begin
   fs := TFileStream.Create(filename, fmOpenReadWrite or fmShareExclusive);
   try
      // Datei auf nächste Blockgrösse verlängern, damit der "Slack" überschrieben
      // wird
      fs.Size := ((fs.Size div BLOCK_SIZE) +2) * BLOCK_SIZE;

      // Datei soll mindestens 2 MB gross sein, damit die Schreibcaches der
      // Festplatten überflutet werden
      if fs.Size < 2097152 then
         fs.Size := 2097152;

      for i := 0 to 5 do
      begin
         fs.Position := 0;
         buffer := StringofChar(Fillchars[i], BLOCK_SIZE);

         for j := 1 to fs.Size div BLOCK_SIZE do
         begin
            fs.WriteBuffer(buffer[1], BLOCK_SIZE);
         end;
         FlushFileBuffers(fs.Handle);
      end;

      // zum Schluss belanglose Daten schreiben
      buffer := '2g642467894erp46FGHTZ&%%&/&)$%"&$%& 5675645 ';
      fs.Position := 0;
      for j := 1 to fs.Size div Length(buffer) do
      begin
         fs.WriteBuffer(buffer[1], Length(buffer));
      end;
   finally
      fs.Free;
   end;
end;


procedure ShredderAndDeleteFile(const filename:string);
var
   newname : string;
begin
   // zuerst umbennen, dann später keine Rückschlüsse auf den Dateinamen möglich sind
   newname := ExtractFilepath(Filename)+'$000000.tmp';

   if not RenameFile(Filename, newname) then
      raise Exception.CreateFmt('Can''t rename file %s', [filename]);

   ShredderFile(newname);

   DeleteFile(newname);
end;

Torry's Delphi Pages:

Delphi-Quellcode:

procedure WipeFile(FileName: string);
var
  buffer: array [0..4095] of Byte;
  max, n: LongInt;
  i: Integer;
  fs: TFileStream;

  procedure RandomizeBuffer;
  var
    i: Integer;
  begin
    for i := Low(buffer) to High(buffer) do
      buffer[i] := Random(256);
  end;
begin
  fs := TFilestream.Create(FileName, fmOpenReadWrite or fmShareExclusive);
  try
    for i := 1 to 3 do
    begin
      RandomizeBuffer;
      max := fs.Size;
      fs.Position := 0;
      while max > 0 do
      begin
        if max > SizeOf(buffer) then
          n := SizeOf(buffer)
        else
          n := max;
        fs.Write(Buffer, n);
        max := max - n;
      end;
      FlushFileBuffers(fs.Handle);
    end;
  finally
    fs.Free;
  end;
  Deletefile(FileName);
end;

Welcher Code ist denn nun besser, im Sinne von macht es richtig und Datei kann nicht wiederhergestellt werden?

[himitsu]

Die Datei einfach nur mit Nullen zu füllen und das auch nur einmal reicht heutzutage vollkommen aus.

Wobei man eventuelle Datenkopieen im Dateisystem eh nicht komplett wegbekommt.
(z.B. durch das Defragmentieren oder andere alte Daten)
Es sei denn man überschreibt auch noch den kopletten ungenutzen Speicher und die nungenuzten Clusteruntiele am Ende aller Dateien, sowie die ungnutzten Clusteranteile in den via NTFS komprimierten Dateien (und vielleicht in den Sparcefiles)

[Luckie]

Das war eine Politiker Antwort. Bloß nicht klar Stellung beziehen. Welche Version würdest du denn jetzt vorziehen?

[p80286]

die Version von shmia ist die "bessere", da er wenn ich es richtig gelesen habe über das Dateiende hinaus den letzten Cluster noch überschreibt.

Welches Muster mann nimmt ist da ziemlich egal.
Ach ja Cluster oder Sektor-Größe?
Nimm das was größer ist, damit kein Verschnitt übrig bleibt. Es sind ja in der Zwischenzeit schon 4k-Platten verfügbar (mit log 0.5k-Sektoren)

Und nach dem Löschen Defragmentieren, und die freien Plattenbereiche mit Müll (#00) beschreiben.

Aber:
1) was ist mit den Alt.DataStreams?
2) Wenn die Datei auf einem Server liegt, gibt es schließlich automatisierte Backups etc.

Gruß
K-H

Edith:
an die (ntfs)komprimierten hab ich garnicht gedacht!

[himitsu]

*überleg*

Da beide Codes mit Dateien über 2, bzw. 4 GB Probleme haben ....
keinen


Ich würde jetzt auf die Schnelle 'nen Teil vom Letzeren etwas verändert verwenden:

Delphi-Quellcode:

procedure WipeFile(const FileName: string);
var
  buffer: array [0..8191] of Byte;
  i: Int64;
  fs: TFileStream;

begin
  fs := TFilestream.Create(FileName, fmOpenReadWrite or fmShareExclusive);
  try
    i := fs.Size;
    while i > 0 do
    begin
      fs.WriteBuffer(Buffer, SizeOf(buffer));
      Dec(i, SizeOf(buffer));
    end;
    FlushFileBuffers(fs.Handle);
  finally
    fs.Free;
  end;
  DeleteFile(FileName);
end;

und dann für größere Dateien noch ein bissl die Speicherverwaltung/WindowsFileCache optimieren:

Delphi-Quellcode:

procedure WipeFile(const FileName: string);
var
  buffer: array [0..8191] of Byte;
  i: Int64;
  fs: TFileStream;

begin
  fs := TFilestream.Create(FileName, fmOpenReadWrite or fmShareExclusive);
  try
    i := (fs.Size + SizeOf(buffer) - 1) div SizeOf(buffer);
    while i > 0 do
    begin
      fs.WriteBuffer(Buffer, SizeOf(buffer));
      if i and $7F = 0 then FlushFileBuffers(fs.Handle);
      Dec(i);      
    end;
    FlushFileBuffers(fs.Handle);
  finally
    fs.Free;
  end;
  DeleteFile(FileName);
end;

Stattdessen könnte man auch direkt die WinAPI verwenden.
> CreateFile OPEN_EXISTING FILE_FLAG_WRITE_THROUGH FILE_FLAG_SEQUENTIAL_SCAN

Zitat:

Zitat von p80286

Ach ja Cluster oder Sektor-G?
Nimm das was größer ist, damit kein Verschnitt übrig bleibt.

Clustergröße = n * Sektorgröße

Zitat:

Zitat von p80286

1) was ist mit den Alt.DataStreams?

Die bleiben erhalten :lol:

Zitat:

// zuerst umbennen, dann später keine Rückschlüsse auf den Dateinamen möglich sind

NTFS ist ein JFS (JournalingFileSystem) und merkt sich alles mögliche.

[Luckie]

also du überschreibst die Datei in deiner zweiten Version einmal? Aber wo initialisierst du buffer?

[p80286]

@Himitsu

Bei der Sektorgröße dachte ich an die neuen 4k Sektoren (gibt's nicht auch schon größere?)
theoretisch besteht da die Möglichkeit, das der phys. Sektor größer als der Cluster wird.

Gruß
K-H

[himitsu]

Nee nee, Cluster ist die logischer Verwaltungseinheit des Dateisystems und diese ist immer ein vielfaches der Sektorgröße.

Der Sektor ist die logische Verwaltungseinheit des Datenträgers
und weniger kann er nicht direkt Adressieren.

Direkte Schreibzugriffe auf die Platte funktioniert auch nur mit Vielfachen der Sektorgröße.

Zitat:

also du überschreibst die Datei in deiner zweiten Version einmal?

Jupp, ist vollkommen ausreichend.
Die theorie von diffundierenden Daten ist bei den kleinen Stukturen heutiger Platten nicht anwendbar
und z.B. SSDs oder USB-Sticks haben sowas nichteinmal.

Zitat:

Aber wo initialisierst du buffer?

garnicht :oops:

Kannst ja gerne noch ein FillChar(buffer, SizeOf(buffer), 0); vorne einfügen,

aber wozu?
Ob nun mit Null, einem bestimmten Muster oder mit zufälligen Daten vom Stack ... die Datei ist futsch. :angel:

[negaH]

ich würde garkeinen empfehlen, da es nur Augenwischerei ist. Willst du es sicherer dann sollte der gespeicherte Context der Datei immer verschlüsselt sein. Das trifft dann auch innerhalb des Speichers der eigenen Anwendung zu da ja auch dort das OS Teile der Anwendung dynamisch und unsichtbar für uns in die Swapdatei auslagern kann. (was aber programtechnisch abschaltbar ist).

Kann man das so umsetzen dann reicht ein DeleteFile() um diese Datei sicher zu löschen ;)

Gruß Hagen

[p80286]

@Himitsu
Darf ich Dir die letzte oder vorletzte ? C't ans Herz legen?
Phys. haben die Platten 4k-Sektoren, die über "tricksereien" als 512B-Sektoren an das DOS weitergegeben werden. Wenn Du also nur mit 2K-Clustern arbeitest (das waren glaube ich Festplatten<32MB) hast Du am Dateiende 2k Verschnitt, die Du auch noch überschreiben solltest um die Sicherheit zu erhöhen.
Ich weiß jetzt nicht mehr ob es schon 64K-Sektoren gibt, aber da ist wohl was in der Pipeline, und das sollte man zumindestens im Hinterkopf behalten.

Ach ja,
bei Sticks hilft das alles nicht viel, weil der erst vollgeschrieben wird, und erst dann wird überschrieben. Da also nur richtig Formatieren!

Gruß
K-H