Bezpieczne kasowanie informacji

Usuwanie danych z dysku przez „Przenieś do Kosza” i „Opróżnij Kosz” może dawać namiastkę pozbycia się danych. Każdy program do odzyskiwania danych poradzi sobie z taką metodą szybciej, niż zdążylibyśmy powiedzieć „nigdy nie posiadałem na dysku tych ściśle tajnych informacji„. Co jednak w przypadku, gdy chcemy wyrzucić pliki raz na zawsze?

Najprostszą (i jednocześnie bardzo skuteczną) metodą jest wielokrotne zamazanie fragmentu dysku, w którym znajdował się plik losowymi danymi. Im więcej razy nadpiszemy losowymi danymi dany obszar, tym trudniej będzie odzyskać z niego sensowne dane nie otrzymując w rezultacie kupy śmieci.

Tym razem algorytm w postaci funkcji w języku Delphi, razem z użyciem:

{$apptype console}

uses
  Windows, SysUtils,Classes;

const
  NFIN = '10Omni-004-003-n_u_6.bsl';
  NFOUT = 'Rezultat.txt';
  N = 20;

  { zwracana wartość: 0 - sukces, 1 - brak pliku do usunięcia }
  function EraseFile(FileName : string) : byte;
  var
    Src, Dst : File;
    Res : TextFile;
    BytesRead, BytesWrite : Integer;
    FullChunks : Integer;
    LastChunkSize : Integer;
    TotalBytes : Integer;
    Tot : Integer;
    Buff : array[0..1024] of Byte;
    i, j, k : integer;

    bufor : array[0..44] of char;
    nBuf : DWord;
    Autor : string;

  begin
    FullChunks := 0;
    LastChunkSize := 0;
    TotalBytes := 0;

    if (not FileExists(FileName)) then
    begin
      EraseFile := 1;
      Exit;
    end;

    {
      zczytanie rozmiaru pliku - ilość bloków 1024-bajtowych
      oraz rozmiaru ostatniego, mniejszego bloku
    }
    AssignFile(Src, FileName);
    try
      Reset(Src, 1);
      try
        repeat
          BlockRead(Src, Buff, 1024, BytesRead);
          TotalBytes := TotalBytes + BytesRead;
          LastChunkSize := BytesRead;
          Inc(FullChunks);
        until (BytesRead = 0) or (1024 <> BytesRead);
      finally
      end;
    finally
      CloseFile(Src);
    end;

    Tot := TotalBytes;
    Dec(FullChunks);

    { N - ilość zamazywań }
    for k := 1 to N do
    begin
      randomize;
      AssignFile(Dst, FileName);
      try
        ReWrite(Dst, 1);

        { zamazywanie pełnych, 1024-bajtowych bloków }
        for i := 1 to FullChunks do
        begin
          for j := 1 to 1024 do Buff[j] := random(255);
          BlockWrite(Dst, Buff, 1024, BytesWrite);
          TotalBytes := TotalBytes - BytesWrite;
        end;

        { zamazywanie ostatniego bloku }
        for i := 1 to LastChunkSize do Buff[i] := random(255);
        BlockWrite(Dst, Buff, LastChunkSize, BytesWrite);
        TotalBytes := TotalBytes - BytesWrite;
      finally
        CloseFile(Dst);
      end;
    end;

    { pobranie aktualnego usera }
    nBuf := length(bufor);
    if GetUserName(bufor, nBuf) then
      Autor := strpas(bufor)
    else
      Autor := 'Nieznany';

    DeleteFile(FileName);

    { uzupełnienie info o usuwaniu }
    AssignFile(Res, NFOUT);
    ReWrite(Res);
    WriteLn(Res, 'Pomyślnie wymazano dane z pliku: ', FileName);
    WriteLn(Res, 'Rozmiar wymazywanego pliku: ', Tot);
    WriteLn(Res, 'Data: ', DateToStr(date));
    WriteLn(Res, 'Użytkownik: ', Autor);
    CloseFile(Res);
    EraseFile := 0;
  end;

var
  res : byte;

begin
  res := EraseFile(NFIN);
  writeln(res);
  readln;
end.

Algorytm przydatny w przypadku np. prawnej konieczności kasowania danych osobowych.

Be Sociable, Share!
czoper opublikowano dnia 2010-5-18 Kategoria: Programowanie | Tagi:,

Zostaw odpowiedź

(Ctrl + Enter)