1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:

                {**********************}
                {     Master_Fixel     }
                {          u.          }
                {        Maweki        }
                {         2004         }
                {**********************}
      //    Die Funktionen Crypt und EnCrypt    \\
     //     geben als Result den ver- oder       \\
    //       entschlüsselten Text zurück          \\
unit Vignere;

interface
  function Crypt(Key: String; Text: String): String;
  function EnCrypt(Key: String; Text: String): String;

implementation

var
  Liste: Array of Array of Char;
  Filled: Boolean;

Procedure Fill;
const
  Alphabet : array[0..25] of Char =
    ('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
     'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z');
var
  i1, i2: Byte;
begin
  SetLength(Liste, 26, 26);
  for i1 := 0 to 25 do
    for i2 := 0 to 25 do
    begin
      if i1 + i2 > 25 then
        Liste[i1, i2] := Alphabet[i1 + i2 - 26]
      else
        Liste[i1, i2] := Alphabet[i1 + i2];
    end;
  Filled := true;
end;

function Crypt(Key: String; Text: String): String;
var
  i, x: Cardinal;
  i2, i3, x2, Rest: Byte;
  Z: ^Char;
begin
  if filled = false then
    Fill;
  x := Length(Text);
  x2 := Length(Key);
  for i := 1 to x do
  begin
    if not (Text[i] in ['A'..'Z', 'a'..'z']) then
      Continue;
    Z := @Text[i];
    Rest := i mod x2;
    i2 := Ord(Z^) - 65;
    if Rest = 0 then
      i3 := Ord(Key[x2]) - 65
    else
      i3 := Ord(Key[Rest]) - 65;
    if Ord(Z^) > 90 then
      Z^ := Chr(Ord(Liste[i2 - 32, i3]) + 32)
    else
      Z^ := Liste[i2, i3];
  end;
  Result := Text;
end;

function EnCrypt(Key: String; Text: String): String;
var
  i, x: Cardinal;
  i2, i3, Rest, x2: Byte;
  ZwChar: Char;
  C, D: ^Char;
  klein: Boolean;
begin
  if filled = false then
    Fill;
  x := Length(Text);
  x2 := Length(Key);
  for i := 1 to x do
  begin
    if not (Text[i] in ['A'..'Z', 'a'..'z']) then
      Continue;
    C := @Text[i];
    rest := i mod x2;
    if Rest = 0 then
      i3 := Ord(Key[x2]) - 65
    else
      i3 := Ord(Key[Rest]) - 65;
    ZwChar  := Liste[0, i3];
    i2 := 1;
    if Ord(C^) > 90 then
    begin
      klein := true;
      D^ := Chr(Ord(C^) - 32);
    end
    else
    begin
      klein := false;
      D^ := C^;
    end;

    if D^ <> Liste[0, i3] then
      while ZwChar <> D^ do
      begin
        ZwChar := Liste[i2, i3];
        Inc(i2);
      end;
    C^ := Liste[i2 - 1, 0];
    if klein = true then
      C^ := Chr(Ord(C^) + 32);
  end;
  Result := Text;
end;

end.                    

1:
2:
3:
4:

    begin
      klein := true;
      D^ := Chr(Ord(C^) - 32);  //hier knallts
    end                    

1:
2:

if not (Text[i] in ['A'..'Z', 'a'..'z']) then  
      Continue;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

function verschluessle(inhalt, key: string): string;
var neu: char;
 zaehler, pos, verschiebung : integer;
begin
 inhalt := lowercase ( inhalt );
 key := lowercase ( key );
 result:= '';

 for zaehler := 1 to length ( inhalt ) do
  begin
   pos := zaehler mod length ( key );
    // suche die position im key raus, mit der aktuell verschlüsselt
    // werden soll
   if ( pos = 0 ) then pos := length ( key );
    // mod liefert 0 zurück, wenn die letzte position des keys erreicht ist

   verschiebung := ord ( key[pos] ) - 97;
    // verschiebung berechnen
    //   --> -97 ist nötig, da 97 das kleine a ist

   neu := chr ( ord ( inhalt[zaehler] ) + verschiebung );
    // erst den ascii-wert des aktuellen buchstaben rausfinden,
    // dann verschieben und aus ascii den buchstaben bilden

   if ( ord ( neu ) > 122 ) then
    neu := chr ( ord ( neu ) - 26 );
    // wenn der ascii-wert über 122 liegt, müssen 26 stellen abgezogen
    // werden, damit das ergebnis im bereich der kleinen buchstaben liegt

   result := result + neu;
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:

function verschluessle(inhalt, key: string): string;
var neu: char;
 zaehler, pos, verschiebung : integer;
begin
 inhalt := lowercase ( inhalt );
 key := lowercase ( key );
 result:= '';

 for zaehler := 1 to length ( inhalt ) do
  begin
   pos := zaehler mod length ( key );
    // suche die position im key raus, mit der aktuell verschlüsselt
    // werden soll
   if ( pos = 0 ) then pos := length ( key );
    // mod liefert 0 zurück, wenn die letzte position des keys erreicht ist
   verschiebung := ord ( key[pos] ) - 97;
    // verschiebung berechnen
    //   --> -97 ist nötig, da 97 das kleine a ist
   neu := chr ( ord ( inhalt[zaehler] ) + verschiebung );
    // erst den ascii-wert des aktuellen buchstaben rausfinden,
    // dann verschieben und aus ascii den buchstaben bilden
   if ( ord ( neu ) > 122 ) then
    neu := chr ( ord ( neu ) - 26 );
    // wenn der ascii-wert über 122 liegt, müssen 26 stellen abgezogen
    // werden, damit das ergebnis im bereich der kleinen buchstaben liegt
   result := result + neu;
  end;
end;                    

1:

verschiebung := 97 - ord ( key[pos] );                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:

function entschluessle(inhalt, key: string): string;
var neu: char;
 zaehler, pos, verschiebung : integer;
begin
 inhalt := lowercase ( inhalt );
 key := lowercase ( key );
 result:= '';


 for zaehler := 1 to length ( inhalt ) do
  begin
   pos := zaehler mod length ( key );
    // suche die position im key raus, mit der aktuell verschlüsselt
    // werden soll
   if ( pos = 0 ) then pos := length ( key );
    // mod liefert 0 zurück, wenn die letzte position des keys erreicht ist
   verschiebung := ord ( key[pos] ) - 97;
    // verschiebung berechnen
    //   --> -97 ist nötig, da 97 das kleine a ist
   neu := chr ( ord ( inhalt[zaehler] ) - verschiebung );
    // erst den ascii-wert des aktuellen buchstaben rausfinden,
    // dann verschieben und aus ascii den buchstaben bilden
   if ( ord ( neu ) < 97 ) then
    neu := chr ( ord ( neu ) + 26 );  
    // wenn der ascii-wert unter 97 liegt, müssen 26 stellen addiert
    // werden, damit das ergebnis im bereich der kleinen buchstaben liegt
   result := result + neu;  
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

function verschluessle(inhalt, key: string): string;
var neu: char;
 zaehler, pos, verschiebung : integer;
begin
 inhalt := lowercase ( inhalt );
 key := lowercase ( key );
 result:= '';
 for zaehler := 1 to length ( inhalt ) do
  begin
if (inhalt[zaehler]  >='a') and  (inhalt[zaehler] <='z') then
(*wir spielen nur mit den Kleinbuchstaben*)
 begin 
   pos := zaehler mod length ( key );
    // suche die position im key raus, mit der aktuell verschlüsselt
    // werden soll
   if ( pos = 0 ) then pos := length ( key );
    // mod liefert 0 zurück, wenn die letzte position des keys erreicht ist
   verschiebung := ord ( key[pos] ) - 97;
    // verschiebung berechnen
    //   --> -97 ist nötig, da 97 das kleine a ist
   neu := chr ( ord ( inhalt[zaehler] ) + verschiebung );
    // erst den ascii-wert des aktuellen buchstaben rausfinden,
    // dann verschieben und aus ascii den buchstaben bilden
   if ( ord ( neu ) > 122 ) then
    neu := chr ( ord ( neu ) - 26 );  
    // wenn der ascii-wert über 122 liegt, müssen 26 stellen abgezogen
    // werden, damit das ergebnis im bereich der kleinen buchstaben liegt  
 result := result + neu;
end
else begin
  result := result + inhalt[zaehler]  ;

(*tue nichts (oder gib alternativFehlermeldung aus )*)
end;
  
  end;
end;