Frage Betreffs einer simplen Verschlüsselung

[Blup]

Korrekturen und Komentare im Quelltext

Delphi-Quellcode:

function Encode(what: string; key: Integer): WideString; 
var 
  i, o: integer; 
  res: string; 
begin
  i:= 1;                      // String beginnt mit Index 1      
  while i <= length(what) do  // Das letzte Zeichen auch verschlüsseln
  begin 
    o:= ord(what[i])+key; 
    if o > 255 then 
      o := o-256;             // 256..511 -> 0..255 

    res := res+chr(o); 
                              //    if what[i+1] = '' then  // Die Bedingung ist in der Schleife nie erfüllt.
                              //      i:= length(what) 
                              //    else 
      inc(i); 
  end; 
  Result:= res; 
end; 

function Decode(what: string; key: Integer): WideString; 
var 
  i, o: integer; 
  res: string; 
begin 
  for i:=1 to length(what) do // String beginnt mit Index 1 
  begin 
    o:= ord(what[i])-key; 
    if o < 0 then 
      o := o+256;             // -256..-1 -> 0..255

    res := res+chr(o); 
  end; 
  Result:= res; 
end;

function TMainForm.GenerateKey: Integer; 
begin 
  randomize; 

  Result:= random(79)+20;    // 20..98
end; 

procedure TMainForm.Button1Click(Sender: TObject); 
const 
  BufferSize= 1024; 
var 
  WStream,Stream: TFileStream; 
  Buffer: String;                    // String reicht
  done, datasize: LongInt;
  Key: Integer; 
begin 
  if OpenDialogEncrypt.Execute then
  begin
    Stream  := nil;                       // Falls eine Exception beim Erzeugen der Streams auftritt
    WStream := nil;                       // ist Free auf nil-Pointer zulässig
    try 
      Stream := TFileStream.Create(OpenDialogEncrypt.FileName, fmOpenRead); 
      WStream := TFileStream.Create(OpenDialogEncrypt.FileName+'.txt', fmOpenWrite or fmCreate); 

      done := Stream.Size;
      datasize := 2;                      // Wie viele Daten sollen tatsächlich gelesen werden
      SetLength(Buffer, datasize);        // Speicher für den Buffer reservieren
      Stream.Read(Buffer[1], datasize);   // Stream.Read(Key, SizeOf(2));
      Dec(done, datasize);                // Anzahl der restlichen Byte im Stream  
      Key := StrToInt(Buffer);            // Zeichenkette umwandeln

      while (done > 0) do 
      begin 
        datasize = Min(done, BufferSize); // Maximal Daten von der Größe des Buffers lesen
                                          // Stream.Seek(done, soBeginning); Position wird durch Lesen erreicht
        SetLength(Buffer, datasize);  
        Stream.Read(Buffer[1], datasize); 
        Dec(done, datasize);
        Buffer:= Decode(Buffer, Key); 
        WStream.Write(Buffer[1], datasize); 
      end; 
    finally 
      Stream.Free; 
      WStream.Free; 
    end;
  end; 
end; 

procedure TMainForm.ButtonEncryptClick(Sender: TObject); 
begin 
  if MainForm.OpenDialogEncrypt.Execute then 
  begin 
    HandleFile(0, OpenDialogEncrypt.Filename); 
  end; 
end; 

procedure TMainForm.HandleFile(done:Longint; Filename: String); 
const 
  BufferSize = 1024; 
var 
  Stream, WStream: TFileStream; 
  Buffer: String; 
  done, datasize: LongInt;
  Key, i: integer; 
begin 
  Stream  := nil;                       // Falls eine Exception auftritt
  WStream := nil;                       // ist Free auf nil-Pointer zulässig
  try 
                                        // SetLength(Buffer, BufferSize); 
    Key := GenerateKey; 
    Buffer := IntToStr(Key);
 
    case Key of                         // Key könnte eigentlich im Bereich 0..255 liegen 
      0..9:   Buffer := '0' + Buffer;            
      10..99: ;                         // durch die Art der Speicherung auf 2stellig beschränkt
    else
      raise Excpetion.Create(Format('Key %d liegt nicht im gültigen Bereich', [Key]);
    end;

    Stream := TFileStream.Create(Filename, fmOpenRead); 
    WStream := TFileStream.Create(Filename+'.txt', fmOpenWrite or fmCreate); 

    WStream.Write(Buffer[1], Length(Buffer));  // kompletten Key als Zeichenfolge speichern
                                               // WStream.Seek(2, soBeginning); 
    done := Stream.Size; 

    ProgressBar1.Max      := done; 
    ProgressBar1.Position := 0; 
    ProgressBar1.Min      := 0; 

    while (done > 0) do 
    begin 
                                               // Stream.Seek(done, soBeginning); 
      datasize = Min(done, BufferSize);
      SetLength(Buffer, datasize);  
      Stream.Read(Buffer[1], datasize); 
      Dec(done, datasize);
      Buffer:= Encode(Buffer, Key); 
      WStream.Write(Buffer[1], datasize); 

      ProgressBar1.Position := ProgressBar1.Max - done; 
    end; 
  finally 
    Stream.Free; 
    WStream.Free; 
  end; 
end; 

end.

Und noch ein Vorschlag zur Vereinfachung

Delphi-Quellcode:

function Encode(what: string; key: Integer): String; 
var 
  i: integer; 
begin
  Result := what;
  for i := 1 to length(Result) do
    Result[i] := Char((Ord(Result[i]) + Key) mod 256);
end; 

function Decode(what: string; key: Integer): String; 
var 
  i: integer; 
begin 
  Result := what;
  for i := 1 to length(Result) do
    Result[i] := Char((Ord(Result[i]) - Key) mod 256);
end;

Alles ungetestet und ohne Gewährleistung