13 Kryptologie

Grundsätzlich dienen Kryptologiealgorithmen zum Verschlüsseln von sogenanntem Klartext. Dieser Vorgang wird auch als "Codieren" bezeichnet. Die verschlüsselte Nachricht (Chiffre) kann schließlich von einem Empfänger wieder entschlüsselt werden, man spricht vom "Decodieren". Im Allgemeinen muss der Empfänger den entsprechenden "Schlüssel" besitzen, mit dem eine Chiffre wieder in den Klartext übersetzt werden kann.

Je nach dem verwendeten Algorithmus entstehen verschiedenen Chiffren - je nach der "Güte" des Verschlüsselungsalgorithmus kann die geheime Nachricht leichter oder schwieriger geknackt werden...

13.1 Verschiebechiffre

Jeder Buchstabe des Klartextes wird durch einen Buchstaben ersetzt, der um genau k Positionen im Alphabet weiter rechts steht. Da das Alphabet 26 Buchstaben hat, sind somit 26 verschiedene Schlüssel möglich (Julius Caesar verwendete einen Code mit k = 23).

Da es nur 26 mögliche Schlüssel gibt, kann die verschlüsselte Nachricht relativ leicht geknackt werden: Entweder man probiert der Reihe nach jeden Buchstaben aus, oder man analysiert in der verschlüsselten Nachricht den häufigsten Buchstaben (der häufigste Buchstabe steht für das 'e'...).

Wir wenden verschiedene Verfahren für die folgende Textdatei an:

Dies ist der Text, den es zu verschlüsseln gilt.

Die Prozedur für das Kodieren eines Klartextes, der in ASCII-Zeichen auf einem Datenträger im Laufwerk A: vorliegt, benützt lediglich elementare Operationen für Buchstaben. Beachte das Lesen und Schreiben von Textdateien! 

 procedure Tform1.Kodieren1Click(Sender:TObject);
var infile,outfile:textfile;
ch:char;
t:integer;

begin
AssignFile(infile,'a:text');
reset(infile);
assignFile(outfile,'a:code');
rewrite(outfile);

while not eof(infile) do begin
read(infile,ch);
ch:=UpCase(ch);
if (ch>='A') and (ch<='Z') then begin
t:=ord(ch)+12;
if t>ord('Z') then t:=t-26;
ch:=chr(t);
end;
write(outfile,ch);
end;
closeFile(infile);
closeFile(outfile);
end;

Der Inhalt der Chiffre lautet:

PUQE UEF QUZ FQJF, PQZ QE LG HQDEOTXüEEQXZ SUXF. 

procedure TForm1.Dekodieren1Click(Sender:...);
var infile,outfile:textfile;
ch:char;
t:integer;
begin
Assignfile(infile,'a:Code');
reset(infile);
Assignfile(outfile,'a:Decode');
rewrite(outfile);

while not eof(infile) do begin
read(infile,ch);
ch:=UpCase(ch);
if (ch>='A') and (ch<='Z') then begin
t:=Ord(ch)-12;
if t<ord('A') then t:=t+26;
ch:=Chr(t);
end;
Write(outfile,ch);
end;
CloseFile(infile);
CloseFile(outfile);
end;

Damit erhalten wir den folgenden Klartext:

DIES IST EIN TEXT, DEN ES ZU VERSCHLüSSELN GILT.

Insbesonders sind bei diesem Chiffre Satzzeichen und Sonderzeichen nicht verschlüsselt worden...

13.2 Substitutionschiffre

Um das Knacken einer Chiffre schwieriger zu gestalten, verwendet man ein Schlüsselwort, das genau 27 Zeichen lang ist. In diesem Schlüsselwort kommt jeder Buchstabe und das Leerzeichen genau einmal vor. Zum Verschlüsseln wird jeder Buchstabe des Klartextes durch den in der Reihe entsprechenden Buchstaben des Schlüssels ersetzt. Beachte im folgenden Programmausschnitt die Funktion find, die den Index des Buchstabens im Alphabet ermittelt (das Leerzeichen steht an 27. Stelle)! Über die Zeichenkette des Alphabets und des Schlüssels werden die Buchstaben der Chiffre bzw. des Klartextes gefunden. 
 function find(alphabet:string;
ch:char):integer;
var t:integer;
begin
find:=-1;
for t:=1 to 27 do
if ch=alphabet[t] then find:=t;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
alphabet:='ABCDEFGHIJKLMNOPQRSTUVWXYZ ';
subst:=   'INFORMATKSCHBU YXZDEGJLPQVW';
end;

Die Funktion find kann nur den Index von Zeichen finden, die in der
Zeichenkette alphabet enthalten sind. Insbesondere können daher
keine Satzzeichen oder Sonderzeichen codiert werden. Dieser Mangel
stellt ein erhebliches Sicherheitsrisiko dar!

procedure TForm1.Codieren1Click(Sender:TObject);
var infile,outfile:textfile;
ch:char;
begin
AssignFile(infile,'a:text');
reset(infile);
AssignFile(outfile,'a:codef');
rewrite(outfile);
while not eof(infile) do begin
read(infile,ch);
ch:=UpCase(ch);
if (ch>='A') and (ch<='Z') or (ch=' ') then
ch:=subst[find(alphabet,ch)];
write(outfile,ch);
end;
CloseFile(infile);
CloseFile(outfile);
end;

Dadurch erhalten wir die Chiffre:

OKRDWKDEWRKUWERPE,WORUWRDWVGWJRZDFTHüDDRHUWAKHE. 

procedure TForm1.Decodieren1Click(Sender:...);
var infile,outfile:textfile;
ch:char;
begin
AssignFile(infile,'a:codef');
reset(infile);
AssignFile(outfile,'a:decodef');
rewrite(outfile);
while not eof(infile) do begin
read(infile,ch);
ch:=UpCase(ch);
if(ch>='A') and (ch<='Z') or (ch=' ') then
ch:=alphabet[find(subst,ch)];
write(outfile,ch);
end;
CloseFile(infile);
CloseFile(outfile);
end;

Der Klartext lautet somit:

DIES IST EIN TEXT, DEN ES ZU VERSCHLüSSELN GILT.

Obwohl bei dem letzten Codierverfahren Leerzeichen mitverschlüsselt werden, kann eine statistische Analyse der Buchstabenhäufigkeiten den Klartext relativ leicht verraten...

13.3 Transpositionschiffre (Skytale)

Skytale waren zwei Zylinder mit genau dem gleichen Radius. Der Sender wickelte ein schmales Band aus Pergament spiralförmig um seinen Zylinder und schrieb dann der Länge nach seine Nachricht auf das Band. Abgewickelt war das Band unleserlich. Um die Nachricht lesen zu können, musste der Empfänger das Band auf einem Zylinder mit genau dem selben Umfang aufwickeln.

Wir verwenden daher einen Algorithmus, der die Nachricht gleichsam reihenweise in eine Tabelle schreibt. Die Chiffre wird aus den einzelnen Tabellen gewonnen. Da die Reihen der Tabelle gleich sind, kann man durch geeignetes Weiterzählen die Chiffre bilden. Beachte, dass nur Nachrichten einer bestimmten maximalen Länge (hier 252 Zeichen) codiert werden können.
D i e s i s
t e i n T
e x t , d e
n e s z u
v e r s c h
l ü s s e l n
g i l t .
# # # # # # #


Codierter Text:

Dten l #############################i x vüg#############################eeteesi#############################si,srsl############################# n set#############################i dzcl.#############################sTeuhn############################## 

procedure TSkytale.FormCreate(Sender: TObject);
var t:integer;
begin
for t:=1 to 252 do skytal[t]:='#';
end;
procedure TSkytale.Codieren1Click(Sender:...);
var infile,outfile:textfile;
ch:char;
s,t:integer;
begin
AssignFile(infile,'a:text');
reset(infile);
AssignFile(outfile,'a:codes');
rewrite(outfile);
s:=1;
while (not eof(infile)) and (s<=252) do begin
read(infile,skytal[s]);
inc(s);
end;
for s:=1 to 7 do
for t:=0 to 35 do
write(outfile,skytal[s+t*7]);
CloseFile(infile);
CloseFile(outfile);
end;
procedure TSkytale.Decodieren1Click(Sender:...);
var infile,outfile:textfile;
ch:char;
s,t:integer;
begin
AssignFile(infile,'a:codes');
reset(infile);
AssignFile(outfile,'a:decodes');
rewrite(outfile);
for s:=1 to 7 do
for t:=0 to 35 do
read(infile,skytal[s+t*7]);
for s:=1 to 252 do write(outfile,skytal[s]);
CloseFile(infile);
CloseFile(outfile);
end;

Klartext:

Dies ist ein Text, den es zu verschlüsseln gilt. ############################################################################################################################################################################################################

13.4 Bitmanipulation

Da grundsätzlich jedes Zeichen bitweise verändert wird, kann man auch hier von einem Substitutionschiffre sprechen. Trotzdem wird die Sicherheit drastisch erhöht, weil der verschlüsselte Text im Allgemeinen keine Buchstaben erkennen lässt.

Die Bitmanipulation wandelt Klartext in Schlüsseltext um, indem das Bitmuster jedes Zeichens mit einem logischen Operator (AND, OR, NOT, XOR) verändert wird. Wir verwenden hier ein Schlüsselwort und den logischen Operator XOR:
XOR 0 1
0 0 1
1 1 0


Wird ein Byte (des Klartextes) mit einem anderen Byte (dem Schlüssel) mit XOR verknüpft und auf dieses Ergebnis wieder der Schlüssel mit XOR angewendet wird, ergibt sich das ursprüngliche Byte des Klartextes: 

	1 1 0 1       1 0 0 1 Zeichen des Klartextes
XOR	0 1 0 1       0 0 1 1 Schlüssel
	1 0 0 0       1 0 1 0 Zeichen der Chiffre
	1 0 0 0       1 0 1 0 Zeichen der Chiffre
XOR	0 1 0 1       0 0 1 1 Schlüssel
	1 1 0 1       1 0 1 1 Zeichen des Klartextes

Durch die Verwendung eines Schlüssels wird jede verschlüsselte Datei einzigartig (da ja bei jeder Verschlüsselung ein anderer Schlüssel verwendet werden kann). Zum Dekodieren der Datei ist sowohl das Codier-Programm als auch der verwendete Schlüssel notwendig (Sicherheit!). 

procedure TForm1.Codieren1Click(Sender:TObject);
var infile,outfile:textfile;
key,ch:char;
begin
key:=edit1.text[1];
AssignFile(infile,'a:text');
reset(infile);
Assignfile(outfile,'a:codex');
rewrite(outfile);
while not eof(infile) do begin
read(infile,ch);
ch:=chr(ord(key) xor ord(ch));
write(outfile,ch);
end;
CloseFile(infile);
CloseFile(outfile);
end;

Zunächst wird das erste Zeichen der Zeichenkette im Edit-Feld gelesen und im Schlüssel "key" gespeichert. Dann wird die Textdatei zum Lesen und die Datei für den Schlüsseltext zum Schreiben geöffnet. Schließlich wird innerhalb der Schleife jedes Zeichen durch Bitmanipulation und Character-Zuordnungen verändert und auf die Platte geschrieben.

Beachte, dass beide Dateien am Ende geschlossen werden müssen!

Das nebenstehende Programmformular lässt die Auswahl "Codieren" bzw. "Decodieren"

Das im Edit-Feld eingetragene Zeichen wird als Schlüssel verwendet

Auf dem Datenträger liegen schließlich die Dateien "codex" (Schlüsseltext) und "decodex" (entschlüsselter Klartext) auf dem Datenträger im Laufwerk A: vor...

Wir erhalten die Chiffre:

($2a(25a$(/a§$95ma%$/a$2a;4a7$32")-22$-/a&(-5o

(Schlüsselwort 'A')

+'1b+16b'+,b':6nb&',b'1b87b4'01!*.11'.,b%+.6l

(Schlüsselwort 'B') 

procedure TForm1.Decodieren1Click(Sender:...);
var infile,outfile:textfile;
key,ch:char;
begin
key:=edit1.text[1];
AssignFile(infile,'a:codex');
reset(infile);
AssignFile(outfile,'a:decodex');
rewrite(outfile);
while not eof(infile) do begin
read(infile,ch);
ch:=chr(ord(key) xor ord(ch));
Write(outfile,ch);
end;
CloseFile(infile);
CloseFile(outfile);
end;

Falls beim Dekodieren der gleiche Schlüssel wie beim Ko-dieren verwendet wird, lautet der Klartext:

Dies ist ein Text, den es zu verschlüsseln gilt.

13.5 Ausblick - Public Key

Hier hat jeder Teilnehmer einen öffentlichen Schlüssel Eund einen geheimen Schlüssel D, so dass gilt: D(E(m)=m, wobei m den Klartext darstellt. Dieser Schlüssel wird auch als asymmetrisches Kryptosystem bezeichnet, weil mit Hilfe des öffentlichen Schlüssels E jeder Teilnehmer überprüfen kann, ob der Klartext m und D(m) zusammenpassen (dann gilt ja E(D(m)) = m).

Will man eine geheime Nachricht senden, so sucht man sich den öffentlichen Schlüssel E des Adressaten heraus und schickt statt m die Chiffre E(m). Nur der berechtigte Adressat kann mit Hilfe seines geheimen Schlüssels D die Nachricht dechiffrieren - es ist nicht notwendig, vor dem Senden der Nachricht einen geheimen Schlüssel zu vereinbaren (und zu übermitteln).

Wenn ein Teilnehmer eine Nachricht m schickt und beweisen will, dass sie von ihm stammt, kann er zusätzlich D(m) schicken. Durch seinen öffentlichen Schlüssel Ekann sich jeder überzeugen, dass m tatsächlich von ihm gesendet wurde: E(D(m)) = m. D(m) nennt man elektronische Unterschrift.