Verfügbare Informationen zu "Cryptographie"
Qualität des Beitrags: Beteiligte Poster: 4dministr4t0r Forum: Newcomer - Board Forenbeschreibung: Forum für alle "Newcomer" (Alter, Geschlecht etc. egal), die sich im Bereich Systemsicherheit weiterbilden wollen. Chatten könnt Ihr am Ende der Seite! aus dem Unterforum: Tutorials (Info-Texte) Antworten: 1 Forum gestartet am: Samstag 23.12.2006 Sprache: deutsch Link zum Originaltopic: Cryptographie Letzte Antwort: vor 17 Jahren, 4 Monaten, 1 Tag, 6 Stunden, 54 Minuten
Alle Beiträge und Antworten zu "Cryptographie"
Re: Cryptographie
4dministr4t0r - 25.12.2006, 20:51Cryptographie
##############################################################################################
Alle hier geposteten Tutorials sind im www zu finden und nicht von mir. Sie werden unverändert hier dargestellt.
Wir weisen ausdrücklich darauf hin, daß wir mit dieser Ansammlung nicht zu Straftaten aufrufen oder animieren wollen!!!
Alle Tutorials dienen ausschließlich zu Informationszwecken.
Solltest Du ein von Dir erstelltes Tutorial hier finden und mit der Veröffentlichung bei Hackressort nicht einverstanden sein, schick mir eine PM oder Email.
Das Tutorial wird dann entfernt.
Hackressort-Team
##############################################################################################
ii
ii ppppp
ii pp pp
ii pp pp
ii ppppp
pp
pp ip's Tutorial:
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?nxk:pl: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:
--<CODE>--
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.
--<CODEEND-->
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:
--<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;
}
--<CODEEND>--
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:
--<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.
--<CODEEND>--
Hierzu gibt es eigentlich nichtmehr viel zu sagen, deshalb auch gleich der C++
Code:
--<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;
};
--<CODEEND>--
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
3.1 Weitergabe- und Verarbeitungsbedingungen
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Da ich ein Freund von OpenSource bin, könnt ihr dieses Dokument nach
belieben weitergeben, vervielfältigen oder auch einzelne Textstücke
herauskopieren, so lange mein Name (ip) und meine eMail Adresse
(iparanoid@gmx.de) angegeben werden!
Achso... und dieses Dokument darf unter keinen Umständen auf irgend
eine Art kommerziell vertrieben werden!
3.2 THX & Greetz
~~~~~~~~~~~~~~~~
Naja... eigentlich habe ich dieses Tutorial ziehmlich im Alleingang
geschrieben. Dem einzigen dem ich vielleicht Danken könnte, wäre mein
TW Lehrer Herr Franz, der mit so schön das Binäre zahlensystem erklärt
hat ;)
Mit folgendem Code, können Sie den Beitrag ganz bequem auf ihrer Homepage verlinken
Weitere Beiträge aus dem Forum Newcomer - Board
Hallo an die Runde - gepostet von sebuka am Mittwoch 21.03.2007
Steinator - gepostet von Steinator am Samstag 10.02.2007
Ähnliche Beiträge wie "Cryptographie"