Caesar-Chiffre

[Peter_Panther]

Guten Morgen liebe DPs!

Leider habe ich ein paar Probleme beim nachvollziehen des folgenden Quelltextes.

Delphi-Quellcode:

var klar,geheim:string;
laenge,i,key: integer;
z1:byte;
z2:char;

begin
geheim:='';
klar:=edit1.text;
laenge:=lenth(klar);
key:=strtoint(edit2.text);

for i:=1 to laenge do
begin
z1:=ord(klar[i]); {1.}
z1:=z1-65; {Grossbuchstaben ?? - 2.}
z1:=(key+z1) mod 26; { 3. }
z1:=z1+65; { 4.}
z2:=chr(z1); {5.}
geheim:=geheim+z2; {6.}
end;
panel1.caption:=geheim;
end;

Wie der Caesar-Chiffre (verbal formuliert) funktioniert ist mir natuerlich klar.
Habe meinen Quelltext mal an den mir unverstaendlichen Stellen nummeriert.
Vielleicht koennte mir einer kurz erklaeren was an diesen Stellen genau funktioniert.
Waere jedenfalls sehr nett, denn ich moechte ja auch verstehen was da genau passiert.

1. ord(klar[i]) - liefert das die Position des Buchstabens im Alphabet ?
2. z1-65 - warum - 65 ?


Besten dank!

[mkinzler]

Zitat:

1. ord(klar[i]) - liefert das die Position des Buchstabens im Alphabet ?

Nein den ASCII Code des Zeichens

Zitat:

2. z1-65 - warum - 65 ?

ASCII 65 ist das Große A.

[Peter_Panther]

Herzlichen Dank!

okay, aber da sind noch ein paar Stellen die ich nicht ganz verstehe. (siehe Quelltext - bis Nr. 6)
Habe die nur unten nicht aufgefuehrt, weil meine Erklaerungsversuche dafuer vielleicht etwas
zu wage sind

[mkinzler]

3.) Es wird zum ASCII-Wert der Keywert addiert und dann der Restwert gebildet -> Rotationsprinzip nach Z kommt wieder A
4.) Die Position des neuen Zeichens wird wieder in ASCII-Wert zurückgewandelt und
5.) zue einem Zeichen konvertiert.
6.) an den geheimstring angehängt

[Peter_Panther]

Vielen Dank!


Jetzt ist mir einiges klarer!


schoenes Wochenende wuensch ich dann

[himitsu]

1: Ord gibt die Position im Zeichensatz.
2: der Buchstabe A hat die Position 65 (siehe Charmap ... einfach mal über Startnenü>ausführen starten, oder unter Zubehör suchen ... "Zeichensatz" oder so)
und zum Rechnen wird, da ja nur das alphabet im gesamten Zeichensatz verschlüsselt wird, alles nach vorn geschoben, also aus A=65 wird 0 usw.
3: was hat wohl 26 Zeichen ... das Vershlüsselte muß ja in diesem Bereich bleiben, also wird alles was außerhalb (größer) ist in diesen Bereich umgebrochen
4: verschigt den verschlüsselten Wert wieder an seine Position im Zeichensatz, also aus 0 wird 65=A
5: macht aus der Position wieder ein Zeichen
6: sowas willst du wissen?
das ist doch nicht wirklich dein Ernst?

2+5: die OH hätte geholfen OH

vielleich läßt es sich so leichter lesen/verstehen.

Delphi-Quellcode:

z := Ord(klar[i]);
z := z - Ord('A');
z := (z + key) mod 26;
z := z + Ord('A');
geheim[i] := chr(z);

wenn man das dann zusammenfaßt, dann kommt sowas raus
geheim[i] := Chr((Ord(klar[i]) - Ord('A') + Key) mod 26 + Ord('A')); Tja und wie du vielleicht vermutest hattest, ist das nur für Großbuchstaben gültig, also das ganze nochmal für die Kleinbucghstaben, außerdem mußt du aufpassen, denn das Leerzeichen, die Satzzeichen, die Zahlen ... alles ist kein Großbuchstabe und würe durch das "mod 26" in den Bereich der Buchstaben verschoben und väre somit futsch.

Delphi-Quellcode:

var klar,geheim:string;
i,key: integer;

begin
  klar := edit1.text;
  geheim := klar;
  key:=strtoint(edit2.text);
  for i:=1 to length(klar) do
    if klar in ['A'..'Z'] then 
      geheim[i] := Chr((Ord(klar[i]) - Ord('A') + Key) mod 26 + Ord('A'))
    else if klar in ['a'..'z'] then 
      geheim[i] := Chr((Ord(klar[i]) - Ord('a') + Key) mod 26 + Ord('A'));
    panel1.caption:=geheim;
end;

für den gesamten Zeichensazt ginge es dann so (wäre aber nicht zu empfehlen)
geheim[i] := Chr((Ord(klar[i]) + Key) mod 256) das ganze ließe sich dann natürlich auch noch auf andere Zeichen ausweiten.
(PS: auf diese Weise würde aber alles immer nur innerhalb seines Bereichs verschoben)

Delphi-Quellcode:

else if klar in ['0'..'9'] then 
  geheim[i] := Chr((Ord(klar[i]) - Ord('0') + Key) mod 26 + Ord('0'));

[Peter_Panther]

Ui, das war natuerlich eine noch bessere Hilfe!
Ich danke dir!

Nein, Nummer 6 hab ich natuerlich gewusst. Dachte nur es wuerde vielleicht
meine Unwissenheit unterstreichen und es bekommt einer Mitleid und posted mir dann
eine sehr ausfuehrliche Antwort. Lag ich doch richtig, oder ?

Nee, aber im Ernst. Hat mir wirklich geholfen.
Auch fuer die anderen Chiffrierverfahren. Sie beinhalten ja alle
aehnliche Funktionen, von daher war deine Antwort auch quasi "chiffrieruebergreifend" von nutzen.

[nailor]

Ich habe es bestimmt auch in der Delphi-Praxis schon gepostet, aber ich poste es immer wieder gerne, also auch hier noch einmal:

Zitat:

Von Cäsar-Verschlüsselungen in denen irgendwo minus Fünfundsechzig gerechnet wird halte ich nicht viel!

Stellt sich zunächst die Frage, wo die 65 herkommt: Das ist (sehr frei und auch nicht ganz korrekt) nach Ollis Tutorial eine verkappte Repräsentation des Datums 'A' (ein großes A). Die schleicht sich ein, weil irgendwo im Code mit den ASCII-Codes der Buchstaben irgendwelche numerischen Berechnungen modulo 65 durchgeführt werden.

Der imho einzige wirkliche Vorteil dieses Vorgehens ist eine schnelle Ausführungsgeschwindigkeit, aber die spielt bei dem Problem ohnehin im Normalfall eine sehr untergeordnete Rolle. Bleibt im Endeffekt kein wirklicher Vorteil.

Eine alternative Möglichkeit, die Cäsar-Verschlüsselung zu implemetieren, ist es, das Alphabet einmal aufzuschreiben, und darunter nocheinmal das Alphabet aber etwas "verschoben" (d.h. das A steht unter dem D, das B unter dem E usw...). Damit hat man im Grunde eine kleine Datenbank in dem der erste Eintrag der Schlüssel ist, welcher Buchstabe verschlüsselt werden soll und der zweite Eintrag der Wert, auf den der jeweilige Buchstabe abgebildet wird.

Damit umgeht man die folgenden Probleme: Bei der ASCII-Werte-Addition wird angenommen, dass die Buchstaben alle "hintereinander liegen". Das mag zwar bei ASCII-Codierung so sein, aber ist doch eine willkürliche Annahme, die schon dann versagt, wenn auch Kleinbuchstaben verschlüsselt werden sollen. Oder Satzzeichen, Sonderzeichen, andersssprachige Alphabete...
zweites Problem ist, dass davon ausgegangen wird, dass alle Buchstaben "gleich weit" verschoben werden. Wenn man allerdings möchte, dass das A auf das Z abgebildet wird, B auf Y, C auf X usw... bekommt man schon arge Probleme. Das ist dann zwar keine Cäsar-Verschlüsselung mehr, aber ein eng verwandtes Problem, dass sich mit der zweiten Implementierung ungleich einfacher lösen lässt als mit der ersten. Das gilt analog für alle Substiutions-Verschlüsselungen.

Zusammenfassung: leg dir eine Liste (damit könnte ein String oder ein Array oder sonstwas gemeint sein) mit allen Buchstaben/Werten an, die verschlüsselt werden sollen an; und eine weitere Liste, in der an der gleichen Position jeweils der Wert steht, auf den abgebildet wird.
Das ist genauso einfach zu implementieren wie das ASCII-Gerechne, genauso einfach zu verstehen, ein kleines bisschen langsamer, aber dafür ungleich flexibler!