35 Mal überschreiben

[HW764]

Ich habe diesen Code, der eine Datei 6 mal überschreibt.
Nun will ich, dass er diese Datei 35 Mal überschreibt.
Was muss ich ändern? (Beim Pfeil "Hier")

Delphi-Quellcode:

procedure EraseFile(Filename: string);
const
  Buffer = 1024;
  FillBuffer: array[0..5] of Integer = ($00, $FF, $00, $F0, $0F, $00); //<-- Hier
var
  arr: array[1..Buffer] of byte;
  f: file;
  i, j, n: integer; 
begin
  AssignFile(f, FileName);
  Reset(f, 1);
  n := FileSize(f);
  for j := 0 to 5 do
  begin 
    for i := 1 to n div Buffer do
    begin 
      BlockWrite(f, FillBuffer[j], Buffer);
    end; 
  end;
  CloseFile(f); 
  RenameFile(Filename, ExtractFilepath(Filename)+'$000000.tmp');
  DeleteFile(ExtractFilepath(Filename)+'$000000.tmp'); 
end;

[Matze]

Ich denke, du musst überall die "5" durch die "34" ersetzen. Bin mir aber nicht sicher.

Edit: Zu der Klammer: Weißt du, was die einzelnen Werte bedeuten?

[StefanDP]

"FillBuffer" wird "das" sein, was nacheinander über die datei geschrieben wird!
mach einfach was in der art

Code:

  FillBuffer: array[0..35] of Integer = ($00, $FF, $00, $F0, $0F, $00, $FF, $00, $F0, $0F, $00, $FF, $00, $F0, $0F, $00, $FF, $00, $F0, $0F, $00...)

draus
oder lass dein fillbuffer und änder deine schleife in etwas wie ungefähr:

Delphi-Quellcode:

  for j := 0 to 35 do
  begin
    for i := 1 to n div Buffer do
    begin
      BlockWrite(f, FillBuffer[j mod 5], Buffer);
    end;
  end;

vom prinzip her halt, nicht getestet

stefan

[flomei]

Das was in der Klammer steht ist doch der "Fill Buffer".
Ist also nur das womit überschrieben wird, oder?!?

Wenn überhaupt, dann würde ich das wie Matze schon sagt die 5 in der for-Schleife durch eine 35 ersetzen. Das ist ja ne Zählervariable die angibt wie oft überschrieben wird...

MfG Florian :hi:

[edit] Oh... derbe zu spät... [/edit]

[Spezi1980]

Bitte:

Delphi-Quellcode:

procedure EraseFile(Filename: string); 
const 
  Buffer = 1024; 
  Counttowrite = 34;
  FillBuffer: array[0..5] of Integer = ($00, $FF, $00, $F0, $0F, $00); //<-- Hier 
var 
  arr: array[1..Buffer] of byte; 
  f: file; 
  i, j, n: integer; 
begin 
  AssignFile(f, FileName); 
  Reset(f, 1); 
  n := FileSize(f); 
  for j := 0 to Counttowrite do 
  begin 
    for i := 1 to n div Buffer do 
    begin 
      BlockWrite(f, FillBuffer[j], Buffer); 
    end; 
  end; 
  CloseFile(f); 
  RenameFile(Filename, ExtractFilepath(Filename)+'$000000.tmp'); 
  DeleteFile(ExtractFilepath(Filename)+'$000000.tmp'); 
end;

Die Konstante "Counttowrite" gibt an wieviel mal du das überschreiben willst.

[OT] war wohl etwas zu langsam [/OT]

[HW764]

Was muss ich jetzt an deinem Code ändern, wenn ich es 35 mal
überschreiben will?
Etwa so???

Delphi-Quellcode:

procedure EraseFile(Filename: string); 
const 
  Buffer = 1024; 
  Counttowrite = 34; 
  FillBuffer: array[0..5] of Integer = ($00, $FF, $00, $F0, $0F, $00)
var 
  arr: array[1..Buffer] of byte; 
  f: file; 
  i, j, n: integer; 
begin 
  AssignFile(f, FileName); 
  Reset(f, 1); 
  n := FileSize(f); 
  for j := 35 to Counttowrite do  //<-- Hier
  begin 
    for i := 1 to n div Buffer do 
    begin 
      BlockWrite(f, FillBuffer[j], Buffer); 
    end; 
  end; 
  CloseFile(f); 
  RenameFile(Filename, ExtractFilepath(Filename)+'$000000.tmp'); 
  DeleteFile(ExtractFilepath(Filename)+'$000000.tmp'); 
end;

[shmia]

Zitat:

Zitat von HW764

Ich habe diesen Code, der eine Datei 6 mal überschreibt.

Der Code ist Kot. :cyclops:
Denn BlockWrite ist eine gepufferte Funktion; es ist nicht sicher, dass die Daten jemals alle auf die Platte kommen.
35-faches Überschreiben ist übertrieben; am Besten man füllt die Datei zum Schluss mit
zufälligen Schrottdaten, dann versagt jedes Partial Response Verfahren.

Hier ist mein Gegenvorschlag:

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 : TFileStream;
   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;

      // wir verarschen den Geheimdienst und schreiben zum Schluss
      // seltsame Schrottdaten
      // wirkliche Zufallsdaten wären besser, aber das reicht doch auch schon
      buffer := 'Terror, Bin Laden, Sprengstoff, Waffen, Plutonium';
      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;

[Matze]

Ne, also bissle überlegen solltest du schon:

Delphi-Quellcode:

for j := 35 to Counttowrite do

Counttowrite hat den Wert 34.

Somit kann die for-Schleife gar nicht durchlaufen werden.
Du kannst den Code von Spezi1980 1:1 übernehmen.

[HW764]

LOL

Delphi-Quellcode:

   // wir verarschen den Geheimdienst und schreiben zum Schluss 
      // seltsame Schrottdaten 
      // wirkliche Zufallsdaten wären besser, aber das reicht doch auch schon 
      buffer := 'Terror, Bin Laden, Sprengstoff, Waffen, Plutonium';

Aber er Code geht supa! Vielen Dank!

[rantanplan99]

Verscht ihr den HW764 oder verarscht der uns?

[sCrAPt]

Wer ver*rscht hier wen? Ich glaube dass nur shmia den Geheimdienst ver*rscht :roll:

[Spezi1980]

Zitat:

von shmia

Delphi-Quellcode:

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

Moderne Festplatten haben aber teilweise bis zu 8 MB Cache und zukünftige Festplatten werden noch mehr Cache haben. Wenn es möglich ist die größe des Festplattencaches herauszufinden, dann sollte man das abhängig von der eingebauten Festplatte machen.

[Kernel32.DLL]

Ich glaub, nen ähnlichen Thread hatten wir schon mal :roll:

(von wegen Dateien so löschen, dass man sie nicht wiederherstellen kann)

Alle genannten Methoden sind nicht sicher und der Geheimdienst würde wahrscheinlich nur "ÄTSCH!" sagen.

Es gibt ne gute Referenz, mit welchen Methode man Daten sicher von magnetischen Speichern löscht...

Sucht bei Google am besten mal nach Peter Gutmann, University of Auckland (oder halt hier im Forum...)

[mlspider]

Und wie geht das mit einem kompletten Ordner der nicht leer ist???

[Vjay]

Delphi-Quellcode:

for j := 0 to 5 do 
  begin 
    for i := 1 to n div Buffer do 
    begin 
      BlockWrite(f, FillBuffer[j], Buffer); 
    end; 
  end;

Ähm, sagt mal Buffer hin oder her... Müsste dan icht nen Seek an den Dateianfang rein? ;)

[glkgereon]

jetzt aber echt stop mal...

hat dieses programm einen sinn???

welchen???

[nailor]

und kommt fillbuffer[] mit dem index 34 so gut, wenn das nur bis 5 geht?

[supermuckl]

bin jetzt net der caching experte für winAPI
aber kann es sein, das man da nur im cache die daten überschreibt, und dann die festplatte (cache) bzw windows da merkt das es immer das selbe ist, und nur ein oder 2mal das ganze durchführt ?
also nur 2 echte überschreibungen statt finden?

geht ja sicherlich um die security und die möglichkeiten ne festplatte wieder aus zu lesen usw

ich denke da eher an RAW schreibzugriffe die ein forciertes schreiben ermöglichen ?!

[Fossibaer58809]

Wird die Datei (egal welcher hier geposteter Code verwendet wird) jemals überschrieben? Oder landet das alles ganz wo anders auf der Festplatte? Ich denke, dass hier die Festplatte Sektororientiert überschrieben werden muss. Also sind die Codebeispiele doch nur da um sich selbst zu veräppeln. :mrgreen:

[supermuckl]

genau :)

man müsste halt immer die gleiche datei überschreiben ( und zwar an der stelle an der die alte war )

und dann halt das cachen tut mich da jucken.. das hat bestimmt nich den erwünschten effekt wenn man da direkt und schnell hintereinander die gleichen daten in eine datei schreibselt

[nailor]

Zitat:

Zitat von Fossibaer58809

Wird die Datei (egal welcher hier geposteter Code verwendet wird) jemals überschrieben? Oder landet das alles ganz wo anders auf der Festplatte? Ich denke, dass hier die Festplatte Sektororientiert überschrieben werden muss. Also sind die Codebeispiele doch nur da um sich selbst zu veräppeln. :mrgreen:

bei fat(32) und glaube auch bei NTFS sollte das kein problem sein. bei ext3 oder so spässen klappt der code nicht, aber das hat auch kein windows-nutzer.