Warum Verschlüsselung?

[TrackerPolizei]

Einstieg: Cryptographie (Version 1.1)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


0.0 Einführung
~~~~~~~~~~~~~~

Hoi!

Ich will euch mit diesem Tutorial allgemein die Verschlüsselung
von Daten mittels einfachen Beispielen näher bringen und mit
Code-Schnipseln speziell auf Delphi übertragen. Falls ihr euch
nicht mit der Verschlüsselung speziell in Delphi interessiert, sondern
nur allgemein dann müsst ihr nur den 1. Teil lesen. Er behandelt die
Verschlüsselung aus allgemeiner Sicht und nicht auf eine
Programmiersprache bezogen. Im 2. Teil werde ich mehr ins Praktisch
übergehen und werde die Verschlüsselung in C und in Delphi behandeln.
Auf meiner Homepage befindet sich zu C bereits ein Beispielprogramm.
Dann viel Spass und verlegt eure Schlüssel nicht



1.0 Warum Verschlüsselung?
~~~~~~~~~~~~~~~~~~~~~~~~~~

Die Verschlüsselung ist wohl schon fast so alt wie die Menschheit
selsbt. Kriegsherren und Politiker haben schon immer wichtige und
vetrauliche Nachrichten verschlüsseln lassen. Heute, im
Infoamtionszeitalter, spielt die Verschlüsselung aber eine noch nie
da gewesene Rolle. "Cyber Piraten" machen das Internet unsicher und
krallen sich alle Daten die sie in die Finger bekommen. Auch
vertrauliches. Um die Übertragung von Daten (ob jetzt über Internet
oder auf physischen Datenträgern) sicherer zu machen, wurden
verschiedene verschlüsselungsverfahren entwickelt. Zum Beispiel der
weit verbreitete Blowfish Algorhytmus. Mit der Zeit hat sich eine
eigene Wissenschaft um die Verschlüsselungstechnik entwickelt: die
sog. Kryptographie. Verschlüsselung dient also zum Datenschutz, um
unbefugten den Zugriff zu erschweren. Ich will hier aber auch
gleich erwähnen, dass eine Verschlüsselung niemals 100% Schutz
bietet. Es kann immer jemandem gelingen einen Verschlüsselungs
Algorhytmus zu knacken und an die vermeindlich geschützten Daten zu
gelangen.



1.1.0 Verschlüsselungstechnik
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Hier wird es jetzt darum gehen euch einen Einblick in die
Grundlagen der Verschlüsselungstechnik zu bieten. Um später
erfolgreich einen eigenen kleinen Verschlüsselungalgorhytmus zu
schreiben, müssen wir zunächst uns ein wenig mit der Theorie
auseinander setzen. Muss leider sein



1.1.1 Wie soll's funktionieren?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Das Prinzip einer Verschlüsselung ist recht einfach. Ein Zeichen
(zB ein Buchstabe) soll beim verschlüsseln (englisch: encrypting;
daher auch encrypten genannt) in ein anderes Zeichen umgewandelt
werden. Später beim entschlüsseln (englisch decrypting; daher auch
decrypten genannt) soll aus dem verschlüsselten Zeichen der
Ursprungszustannd wieder hergestellt werden. Zum veranschaulichen
hier ein Beispiel:

Ursprung: http://ip-web.hn.org

Verschlüsselt: ueef%§§wq?nxkl:itd

Der Verschlüsselte Text ist nun nicht mehr zu entziffern. Damit
wäre die Zeichenkette http://ip-web.hn.org verschlüsselt und vor
unbefugten Einblicken geschützt. Eine Möglichkeit der
Verschlüsselung ist zB das ersetzen eines jeden einzelnen Zeichnes
durch ein anderes. ZB könnte man mit folgender Tabelle einen Text
verschlüsseln:

A => Z    K => P    U => F
B => Y    L => O    V => E
C => X    M => N    W => D
D => W    N => M    X => C
E => V    O => L    Y => B
F => U    P => K    Z => A
G => T    Q => J
H => S    R => I
I => R    S => H
J => Q    T => G

Man ersetzt einfach jedes Zeichen durch ein anderes dieser Tabelle
entsprechend. Der Morsecode ist auch nichts anderes als eine solche
Verschlüsselung nach einer Tabelle. ZB würde aus dem Wort Hallo nach
dieser Tabelle SZOOL werden. Schon jetzt ist es nicht mehr zu
erkennen. Diese Art der Verschlüsselung ist zwar sehr einfach, aber
auch dementsrechend unsicher. Ein Cryptograph, der eure Verschlüsselten
Daten entschlüsseln will, würde schon sehr bald die Regelmäßigkeit in
eurer Verschlüsselung erkennen.



1.1.2 ASCII Tabellen verschiebung
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Eine nicht unbedingt sicherere Methode der Verschlüsselung ist die
ASCII Tabellen verschiebung.ASCII steht für American Standard Code
for Information Interchange. In der ASCII Tabelle ist jedes Zeichen
mit einer Zahl versehen (einer 1 Byte großen). Jede dieser Zahlen
spiegelt also einen Buchstaben dar. Wenn man nun diese Tabelle
verschiebt (indem man die jedem Buchstaben zugehörige Zahl zB um
eins erhöht) erhalten wir einen neuen Zeichensatz. Somit bietet uns
dies eine recht einfache Möglichkeit der Verschlüsselung. Im
Prinzip ist das ja nichts anderes als eine neue Tabelle
aufzustellen, doch der Vorteil hiervon ist, dass die Tabelle um
eine bestimmte Anzahl von Zeichen verschoben werden kann und somit
eine Art Passwort entsteht. Nur derjenige, der weiß um wieviel
Zeichen die Tabelle verschoben worden ist, kann die Verschlüsselten
Daten auch wieder entschlüsseln. Diese Methode ist jedoch sehr
unsicher und deshalb gehe ich auch hierauf nicht mehr weiter ein.




1.1.3.0 Grundlagen der bitweisen XOR-Verschlüsselung
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Hier werden jetzt bestimmt einige mit der Luke auf dem Boden
hängen. Hört sich kopmpliziert an? Ist warscheinlich auch nicht das
Simpelste, aber doch zu verstehen! Zunächst müssen wir uns ein
wenig mit dem Binären Zahlensystem auseinander setzen, um später
die XOR-Verschlüsselung zu verstehen.



1.1.3.1 Das Binäre Zahlensystem
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Im Binären Zahlensystem gibt es nur 2 Ziffern (im Gegensatz zu
unserem Dezimalen Zahlensystem mit insg. 10 Ziffern 0..9): die Eins
(1) und die Null (0). Mit diesen beiden Ziffern kann man alle
gewünschten Zahlen darstellen. Jetzt werdet ihr euch sicher fragen:
"Wie?!", das ist aber garnicht so schwer. Hier mal ein Beispiel:

Dezimal: 237

Binär: 11101101

Doch wie komme ich darauf? ganz einfach. Die erste Stelle (von
Rechts) in einer Binären Zahl steht für die Eins. Die zweite für die
Zwei, die Dritte für die Vier, die vierte für die Acht die fünfte für
die 16 usw. So lassen sich alle beliebigen Zahlen zusammensetzen. Hier
ein paar Beispiele:

Dezimal    0

Binär:    0    0    0    0    0    0    0    0
    ---------------------------------------------------------
    128    64    32    16    8    4    2    1

    
Dezimal 255

Binär:    1    1    1    1    1    1    1    1
    ---------------------------------------------------------
    128    64    32    16    8    4    2    1

Binäre Zahlen lassen sich jedoch auch anders Beschreiben. Das binäre
Zahlensystem stellt nämlich ein Zahlensystem zur Basis 2 dar, unsere
Dezimalsystem hingegen zur Basis 10. Ein Beispiel soll das
verdeutlichen:


Dezimal: 73

Binär:     0    1    0    0    1    0    0    1
-------------------------------------------------------------------
Exp.    7    6    5    4    3    2    1    0    
Basis  2       2       2       2       2       2       2       2    
-------------------------------------------------------------------
Ergibt 128    64    32    16    8    4    2    1

So steht die erste Ziffer (ganz rechts) für ein 2 hoch 0, die zweite
für 2 hoch 1, dann 2 hoch 2 usw.
Probiert mal ein wenig rum. Rechnet mal was von Dezimal in Binär und
was von Binär nach Dezimal um und überprüft (zB mittels des Windows-
Taschen-Rechners) ob ihr richtig gerechnet habt.
Sobald ihr das binäre Zahlensystem verstanden habt, macht ihr weiter.



1.1.3.2 ASCII Codierung
~~~~~~~~~~~~~~~~~~~~~~~

Und da kommen wir doch wieder zum ASCII Code zurück. Das liegt
daran, dass der Computer-ZeichenSatz auf dem ASCII Code aufbaut.
Zwar ist Moderne Software eigentlich mit dem ANSI Code (eine Art
weiterentwicklung des ASCII Zeichensatzes) kompatibel (zB Windows
etc), doch ist der ASCII Code kleiner und somit übersichtlicher.
Die Codierung eines Schriftzeichens wurde früher (zB bei MS-Dos)
mit dem sog. ASCII Code erfüllt. Da der Speicher keine
Schriftzeichen direkt, sondern nur Zahlen aufnhemen kann (und das
in Form von binären Zahlen, also nur Einsen und Nullen), muss ein
Schriftzeichen im Speicher in der Form einer Zahl dargestellt
werden. Darum wurde der ASCII Code entwickelt. Insgesamt bietet er
Platz für 256 Zeichen. Somit eröffnet sich die Möglichkeit ein
Zeichen im Speicher in Form einer Zahl zwischen 0 und 255 abzulegen.
Da der Speicher eines Computers (und überhaupt der gesamte Computer)
nur Binären Code versteht, wird die Zahl auch in Form von Bits
(eine Ziffer einer Binären Zahl, also eine 1 oder eine 0)
abgelegt. Um eine Zahl zwischen 0 und 255 in binärerer Form
darzustellen brauch man insgesamt 8 Bits (Einsen und Nullen).
Ein Beispiel zur verdeutlichung:

Dezimal    0

Binär:    0    0    0    0    0    0    0    0
    ---------------------------------------------------------
    128    64    32    16    8    4    2    1

    
Dezimal 255

Binär:    1    1    1    1    1    1    1    1
    ---------------------------------------------------------
    128    64    32    16    8    4    2    1

Mit 7 Bits könnte man zB 128 verschiedene Zahlen (inkl der Null)
darstellen:

Dezimal 127

Binär:    1    1    1    1    1    1    1
    -------------------------------------------------
    64    32    16    8    4    2    1

Oder mit 9 Bits zahlen bis 511 (inkl. der Null):

Dezimal 511

Binär    1    1    1    1    1    1    1    1    1
       ------------------------------------------
       256  128   64   32   16   8    4    2    1

Da der Computer immer 8 Bits zu einem Byte zusammenfasst, ist die 8
Bit Variante jedoch die Praktischerere. Also hat ein einzelnes
Zeichen im ASCII Code Format die größe von einem Byte. Erweiterte
Codes (zB ANSI oder der noch rel. neue UniCode) bieten eine größere
Anzahl von Zeichen und sind somit auch größer.



1.2.0 XOR Verschlüsselung
~~~~~~~~~~~~~~~~~~~~~~~~~

Jetzt sollte genug Grundwissen da sein, um sich an die
XOR-Verschlüsselung wagen zu können. Falls ihr das Binäre Zahlensystem
noch nicht verstanden habt, fragt euren Mathelehrer, ob er es euch
vielleicht mal erklären könnte, oder aber wenn ihr nichtmehr zur Schule
geht, holt euch ein einfaches Mathebuch (in einer Bibliothek). Dort
wird es bestimmt auch gut erklärt. Falls ich merke, dass viele von euch
damit Probleme hatten, dann werde ich dieses Thema nocheinmal speziell
in einem seperaten Tutorial behandeln.
Am besten ihr besorgt euch auch eine ASCII Tabelle (findet ihr bestimmt
im Internet iergendwo). Diese wird euch bestimmt sher helfen.



1.2.1 Konkrete Funktionsweise
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Die XOR Verschlüsselung (oder auch Bitweise Exklusiv Verschlüsselung)
baut auch auf der Bereits kennen gelernten ASCII Code verschiebung auf,
nur ist diese Verschiebung bei der Bitweisen XOR Verschlüsselung um
einiges komplexer und somit auch schwerer zu knacken.
Doch was bedeutet dieses XOR eiegentlich? XOR ist eion Operator (in
C durch ein ^ dargestellt, in Pascal/Delphi XOR ausgeschrieben), der
einen bitweisen exklusiv Vergleich zweier Zahlen vornimmt. Das
bedeutet, dass die Zahlen ins Binärsystem umgewandelt werden und dann
verglichen. Das Ergebnis des vergleiches wird wieder in eine
Dezimal-Zahl umgewandelt und ist das Ergebnis der XOR Operation. Der
Vergleich funktioniert folgender Maßen:

Die Zahlen werden Binär dargestellt (mit im Prinzip unendlich vielen
führenden Nullen). Dann wird das Niederwertigste Bit (ganz rechts
außen) der Zahlen verglichen. Ist dieses gleich (0 und 0 - oder - 1 und
1) wird das niederwertigste Bit des Ergebnisses auf 0 gesetzt.
Unterscheidet sich dieses Bit jedoch (1 und 0 - oder - 0 und 1) wird
das niederwertigste Bit des Ergebnisses auf 1 gesetzt.
Hier ein Anschauungsbeispiel:

Deziaml        19         XOR         134      =       149
                 
Binär    0 0 0 1 0 0 1 1   XOR   1 0 0 0 0 1 1 0   =  1 0 0 1 0 1 0 1

Wie man hier sehen kann ist 19 XOR 134 = 149. Die Zahlen scheinen, wenn
man sie sich Deziaml anschaut, keinen Zusammenhang zu haben. Noch
verwirrender (oder verschlüesselnder ;-) ) wird das ganze, wenn diese
Zahlen in Wirklichkeit ASCII Code sind und iergendwelche Buchstaben
darstellen, denn dann ist für den Laien kein zusammenhang mehr
rekonstruierbar. Wir wollen dies an einem Beispiel "beweisen":

ASCII        A      XOR          F          =  Steuerzeichen 7    

Deziaml        65         XOR         70      =       7
                 
Binär    0 1 0 0 0 0 0 1   XOR   0 1 0 0 0 1 1 0   =  0 0 0 1 0 1 1 1

Hier lässt sich sehr gut erkennen, dass kein Zusammenhang zu erkennen
ist. A XOR F ergibt das 7. Steuerzeichen (Am Anfang des ASCII Codes
stehen verschiedene Steurzeichen, zB die Nulltermination, das CR
(Cariage Return bzw. Wagenrücklauf) usw.) Das 7. Steuerzeichen wird für
den Benutzer warscheinlich nichteinmal als zeichen erkannt werden und
trotzdem haben wir darin die Information unseres A (bzw F oder beide)
versteckt. Nun solltet ihr eigentlich Verstanden haben, wie eine XOR
Verschlüsselung funktioniert. Probiert ein wenig rum (am besten benutzt
ihr uach her wieder den Windows Taschenrechner) und versucht euch
vielleicht sogar schon ein wenig mit der Programmierung.



2.0 Praktische Umsetzung
~~~~~~~~~~~~~~~~~~~~~~~~

Dann wollen wir mal sehen, was wir aus dem eben gelernten so machen
können. Ich werde nicht im Detail auf jeden Quelltext eingehen (zumal
ich immer 2 verschiedene, einen in ObjectPascal und einen in C++
zur verfügung stellen werde), doch ich werde euch zeigen, wie man
das programmiert, was ich euch oben erklärt habe.


ASCII Tabellen verschiebung
~~~~~~~~~~~~~~~~~~~~~~~~~~~

So hier erstmal der Pascal Quelltext:

var
  S: String ;
  I: Integer;
begin
  Write('Source: ');
  ReadLn(S);
  { Wir verschlüsseln den Text, indem wir ihn auf der ASCII Tabelle
    um 5 Stellen nach links verschieben. }
  for I := 1 to Length(S) do
    S[i] := Chr(Ord(S[i])-5);
  WriteLn('Crypted: '+S);
  { Nun entschlüsseln wir den Text wieder, indem wir die Verschlüsselung
    umkehren und den verschlüsselten Text einfach wieder um 5 Stellen
    nach rechts verschieben. }
  for I := 1 to Length(S) do
    S[i] := Chr(Ord(S[i])+5);
  WriteLn('Decrypted: '+S);
  ReadLn;
end.

Auf was ich kurz eingehen will, sind die 2 Funktionen Chr und Ord:
Ord liefert den ASCII Code eines Zeichens und Chr wandelt eine
Zahl anhand der ASCII Tabelle in ein Zeichen um. Also nichts
besonderes.

Für unsere C++ Fans hier der C++ Code:

int main(){
    cout << "Source: ";
        char s[256] = "";
        cin >> s;
    /* Wir verschlüsseln den Text, indem wir ihn auf der ASCII Tabelle
           um 5 Stellen nach links verschieben. */
        for(int i=0;i<strlen(s);i++)
        s[i] += 5;
    cout << "Crypted: " << s;
    /* Nun entschlüsseln wir den Text wieder, indem wir die Verschlüsselung
           umkehren und den verschlüsselten Text einfach wieder um 5 Stellen
           nach rechts verschieben. */
    for(int i=0;i<strlen(s);i++)
        s[i] -= 5;
    cout << "Decrypted: " << s;
    getch();    
    return 0;
}

Hier gibt es eigentlich nichts besonderes zu erklären. Ein durchschnittlicher
C++ Programmierert sollte hier alles mit Leichtigkeit verstehen können.

Die bitweise XOR-Verschlüsselung
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Hier zunächst wieder der ObjectPascal Code:

var
  S,P: String ;
  I,J: Integer;

begin
  Write('Source: ');
  ReadLn(S);
  Write('Pass:' );
  ReadLn(P);
  { Wir verschlüsseln den Text, indem wir ihn jeden Buchstaben des
    Textes mit einem Buchstaben des Passwortes verschlüsseln. }
  J := 1;
  for I := 1 to Length(S) do
  begin
    S[i] := Chr(Ord(S[i]) xor Ord(P[J]));
    Inc(J);
    { Wenn das Passwort einmal "durchlaufen" ist, soll das Programm
      das Passwort erneut durchlaufen, bis das gesamte Wort verschlüsselt
      ist. }
    if J > Length(P) then
      J := 1;
  end;
  WriteLn('Crypted: '+S);
  { Nun entschlüsseln wir den Text wieder, indem wir die Verschlüsselung
    umkehren und den jeden Buchstaben des verschlüsselten Text einfach wieder
    mit jedem Buchstaben des (neuen) Passwortes XOR-Verknüpfen. }
  J := 1;
  for I := 1 to Length(S) do
  begin
    S[i] := Chr(Ord(S[i]) xor Ord(P[J]));
    Inc(J);
    { Wenn das Passwort einmal "durchlaufen" ist, soll das Programm
      das Passwort erneut durchlaufen, bis das gesamte Wort verschlüsselt
      ist. }
    if J > Length(P) then
      J := 1;
  end;
  WriteLn('Decrypted: '+S);
  ReadLn;
end.

Hierzu gibt es eigentlich nichtmehr viel zu sagen, deshalb auch gleich der C++
Code:

int main(){
char s[256] = "";
char p[256] = "";
cout << "Source: ";
cin >> s;
cout << "Pass: ";
cin >> p;
/* Wir verschlüsseln den Text, indem wir ihn jeden Buchstaben des
Textes mit einem Buchstaben des Passwortes verschlüsseln. */
int j=0;
for(int i=0;i<strlen(s);i++){
s[i] ^= p[j++];
/* Wenn das Passwort einmal "durchlaufen" ist, soll das Programm
das Passwort erneut durchlaufen, bis das gesamte Wort verschlüsselt
ist. */
if(j>=strlen(p))
j=0;
};
cout << "Crypted: " << s;
/* Nun entschlüsseln wir den Text wieder, indem wir die Verschlüsselung
umkehren und den jeden Buchstaben des verschlüsselten Text einfach wieder
mit jedem Buchstaben des (neuen) Passwortes XOR-Verknüpfen. */
j=0;
for(int i=0;i<strlen(s);i++){
s[i] ^= p[j++];
/* Wenn das Passwort einmal "durchlaufen" ist, soll das Programm
das Passwort erneut durchlaufen, bis das gesamte Wort verschlüsselt
ist. */
if(j>=strlen(p))
j=0;
};
cout << "Decrypted: " << s;
getch();
return 0;
};

Auch hier wüßte ich nicht, was ich wieder groß erklären soll... alle
mißverständlichen/nicht sofort einleuchtende Sachen sind bereits durch
Quelltextkommentare erklärt.
Na dann, hoffe es hat euch Spass gemacht und ihr habt was gelernt

3.0 Anhang
~~~~~~~~~~

Falls ihr noch Fragen habt bezüglich meines Tutorials, mailt mir:
iparanoid@gmx.de!
En paar Foren an denen ihr mich antreffen könnt:
-www.root-shell-club.com
-www.delphi-source.de/interakiv/forum.shtml

Dann natürlich noch meine Homepage:
http://ip-web.hn.org