Delphi Kryptologie

[LEmax474]

Hallo ihr Lieben,
ich soll für die Schule ein kleines Verschlüsselungsprogramm schreiben, indem wir auch die VErschlüsselung uns ausdenken. Es muss nichts hochsicheres sein aber es sollte funktionieren. Es ist eine Vigenere-Verschlüsselung.
Ich möchte, dass der Benutzer ein Passwort eingibt und dann beginnt folgendes:
Das Programm soll die erste Hälfte des Textes mit der Procedure Vigenere Verschlüsseln, die zweite Hälfte des Textes mit der Procedure Vigenerzwei: Vigenerezwei nutzt den umgedrehten Schlüssel.
BSP: Hallo_wie_geht_es sind 17 Buchstaben (Leerzeichen ist _) Somit sollen die ersten 9 mit dem richtigen PW (zb.Hallo) verschlüsselt werden, die restlichen 8 mit dem umgerehten PW (ollah)
Nun ist meine Frage: kann sich jemand mal meinen Quelltext anschauen und mir sagen wie man diese Unterteilung macht? (am betsen auch noch für das entschlüsseln)
Dazu sei gesagt dass ich und mein Kumpel uns schon 3Stunden damit aberackert haben das zuschreiben mit :
for i := 1 to (length(klartext) div 2) usw hat es nicht richtig funktioniert.

Delphi-Quellcode:

UNIT uKryptobox;
(* ******************************************************************** *)
(* K L A S S E : TKryptobox                                             *)
(* -------------------------------------------------------------------- *)
(* Aufgabe     : Einen Text ver- und entschluesseln nach dem Caesar-    *)
(*               verfahren. Der Rohtext wird vorbehandelt: nur 'A'..'Z' *)
(*               zugelassen, kleine Buchstaben werden in grosse umgewan-*)
(*               Blanks, Satzzeichen als Blanks, der Rest wird ausgefil-*)
(*               tert.                                                  *)
(* ******************************************************************** *)

INTERFACE
(* ========================== Export ================================== *)
uses Sysutils, classes, dialogs, StrUtils;

type
  TKryptoBox = class
              private
               Klartext,
               Geheimtext : string;
               Schluessel : string;
               key        : integer;
              public
               constructor Init;
               procedure  SetKlartext (kt : string);
               function   GetKlartext : string;
               procedure  SetGeheimtext (gt : string);
               function   GetGeheimtext : string;
               procedure  Verschluesseln;              virtual;
               procedure  Entschluesseln;              virtual;
               procedure  SetSchluessel (s : string);  virtual;
               procedure vigenere;
               procedure entvigenere;
               procedure vigenerezwei;
               procedure entvigenerezwei;
               procedure umdrehen;

              private
               function  GetStellenWertVon (Zeichen : char) : integer;
               function  GetZeichenVon (StellenWert : integer) : char;
               procedure Vorbehandeln (var txt : string);
             end;




IMPLEMENTATION
(* ==================================================================== *)

constructor TKryptobox.Init;
(* -------------------------------------------------------------------- *)
begin
  Klartext   := '';
  Geheimtext := '';
end;

procedure TKryptobox.SetKlartext (kt : string);
(* -------------------------------------------------------------------- *)
begin
  Klartext := kt
end;


function TKryptobox.GetKlartext : string;
(* -------------------------------------------------------------------- *)
begin
  Result := Klartext
end;


procedure TKryptobox.SetGeheimtext (gt : string);
(* -------------------------------------------------------------------- *)
begin
  Geheimtext := gt;
end;


function TKryptobox.GetGeheimtext : string;
(* -------------------------------------------------------------------- *)
begin
  Result := Geheimtext;
end;


procedure TKryptobox.SetSchluessel (s : string);
(* -------------------------------------------------------------------- *)
begin
   if s =''
   then Schluessel := 'a'
   else schluessel := s  ;
end;


procedure TKryptobox.Verschluesseln;
(* -------------------------------------------------------------------- *)
var
i : integer;
begin
  vigenere;
  vigenerezwei;
   end;


procedure TKryptobox.Entschluesseln;
begin
 entvigenere;
 entvigenerezwei;
end;

function TKryptoBox.GetStellenWertVon (Zeichen : char) : integer;
(* -------------------------------------------------------------------- *)
begin
   case Zeichen of
    'A'..'Z' : Result := ord(Zeichen) - 65 ;
     ' '     : Result := 26;
   end;
end;


function TKryptoBox.GetZeichenVon (StellenWert : integer) : char;
(* -------------------------------------------------------------------- *)
begin
   case Stellenwert of
     0..25 : Result := chr(Stellenwert + 65);
        26 : Result := ' ';
   end;
end;


procedure TKryptoBox.Vorbehandeln (var txt : string);
(* -------------------------------------------------------------------- *)
(* Auftrag: Rohtext von störenden Zeichen befreien                      *)
(* vorher :                                                             *)
(* nachher: kleine in GROSSE Buchstaben gewandelt; Umlaute umgewandelt; *)
(*          LeerZeichen, Satzzeichen als BLANK;                         *)
(* -------------------------------------------------------------------- *)
var
  i         : integer;
  Zeichen   : char;
  Hilfstext : string;

begin
   Hilfstext := '';

   for i := 1 to Length(txt) do
   begin
     Zeichen := txt[i];

     case Zeichen of

     'A'..'Z' : begin
                   Hilfstext := Hilfstext + Zeichen;
                end;

     'a'..'z' : begin
                   Zeichen   :=  UPCASE(Zeichen);
                   Hilfstext := Hilfstext + Zeichen;
                end;


     'Ä', 'ä' : begin
                   Zeichen   := 'A';
                   Hilfstext := Hilfstext + Zeichen;
                   Zeichen   := 'E';
                   Hilfstext := Hilfstext + Zeichen;
                end;

     'Ö', 'ö' : begin
                   Zeichen := 'O';
                   Hilfstext := Hilfstext + Zeichen;
                   Zeichen := 'E';
                   Hilfstext := Hilfstext + Zeichen;
                end;

     'Ü', 'ü'  : begin
                   Zeichen   := 'U';
                   Hilfstext := Hilfstext + Zeichen;
                   Zeichen   := 'E';
                   Hilfstext := Hilfstext + Zeichen;
                 end;

     'ß'      : begin
                   Zeichen   := 'S';
                   Hilfstext := Hilfstext + Zeichen;
                   Zeichen   := 'S';
                   Hilfstext := Hilfstext + Zeichen;
                end;

     chr(32)  : begin
                  Zeichen   := ' ';
                  Hilfstext := Hilfstext + Zeichen;
                end;

     chr(13)  : begin
                  Zeichen   := ' ';
                  Hilfstext := Hilfstext + Zeichen;
                end;

     '.'      : begin
                  Zeichen   := ' ';
                  Hilfstext := Hilfstext + Zeichen;
                end;

     ','      : begin
                  Zeichen   := ' ';
                  Hilfstext := Hilfstext + Zeichen;
                end
       else
               begin    (* den Rest ueberlesen *)
               end;
     end; (* case *)
   end;   (* while *)

   txt := '';   // urspruenglichen Text loeschen und neuen zuweisen
   txt := Hilfstext;
end;


procedure TKryptobox.vigenere;
 var
  i,a,b,c,
  KTWert,
  GTWert  : integer;
  Zeichen : char;
begin
  Geheimtext := '' ;
  Vorbehandeln(Klartext);
  Vorbehandeln(schluessel)   ;
    // hier kommt Ihr Verschluesselungsalgorithmus hin!
  b:= 1;
  for i := 1 to (length(klartext)) do
  begin
  Zeichen :=  klartext[i]         ;
  Ktwert := Getstellenwertvon(klartext[i])  ;
  c := Getstellenwertvon(schluessel[b])  ;
  a :=  KTwert +  c   ;
  Zeichen := Getzeichenvon(a mod 27);
  Geheimtext:= Geheimtext + zeichen  ;
  b := (b + 1) mod (length(schluessel)+1) ;
  If b = 0 then
  b := 1 ;
  end;


END;

procedure tkryptobox.entvigenere;
var
  i,b,a,c ,d ,
  KTWert,
  GTWert  : integer;
  Zeichen : char;

begin
  Klartext := '' ;

  Vorbehandeln(schluessel)   ;
  // hier kommt Ihr Verschluesselungsalgorithmus hin!
  b:= 1;
  for i := 1 to (length(Geheimtext)-2) do
  begin

  Zeichen :=  Geheimtext[i]         ;
  Ktwert := Getstellenwertvon(Geheimtext[i])  ;
  c := Getstellenwertvon(schluessel[b])  ;
   a :=  (KTwert -  c+27) mod 27   ;
  Zeichen := Getzeichenvon((a));
  Klartext := Klartext + Zeichen ;
  d:=      (length(schluessel)+1) ;
  b:= b + 1     ;
  b := (b) mod d;
  If b = 0 then
  b := 1 ;

end;
end;


procedure tkryptobox.vigenerezwei;
 var
  i,a,b,c,
  KTWert,
  GTWert  : integer;
  Zeichen : char;
begin
umdrehen;
  Geheimtext := '' ;
  Vorbehandeln(Klartext);
  VOrbehandeln(schluessel)   ;
  showmessage(schluessel);
  // hier kommt Ihr Verschluesselungsalgorithmus hin!
  b:= 1;
  for i := 1 to (length(klartext)) do
  begin
  Zeichen :=  klartext[i]         ;
  Ktwert := Getstellenwertvon(klartext[i])  ;
  c := Getstellenwertvon(schluessel[b])  ;
  a :=  KTwert +  c   ;
  Zeichen := Getzeichenvon(a mod 27);
  Geheimtext:= Geheimtext + zeichen  ;
  b := (b + 1) mod (length(schluessel)+1) ;
  If b = 0 then
  b := 1 ;
  end;


END;



procedure tkryptobox.entvigenerezwei;

var
  i,b,a,c ,d ,
  KTWert,
  GTWert  : integer;
  Zeichen : char;

begin
  umdrehen;
  Klartext := '' ;

  Vorbehandeln(schluessel)   ;
  // hier kommt Ihr Verschluesselungsalgorithmus hin!
  b:= 1;
  for i := 1 to (length(Geheimtext)-2) do
  begin

  Zeichen :=  Geheimtext[i]         ;
  Ktwert := Getstellenwertvon(Geheimtext[i])  ;
  c := Getstellenwertvon(schluessel[b])  ;
   a :=  (KTwert -  c+27) mod 27   ;
  Zeichen := Getzeichenvon((a));
  Klartext := Klartext + Zeichen ;
  d:=      (length(schluessel)+1) ;
  b:= b + 1     ;
  b := (b) mod d;
  If b = 0 then
  b := 1 ;
 end;
end;

procedure tkryptobox.umdrehen;
begin
 schluessel := reverseString(schluessel)
end;

end.

Anbei kann ich euch den link geben dass ihr euch das auf den rechner ladet.

[edit=Phoenix]Code in Delphi-Tags geändert. Mfg, Phoenix[/edit]