Ich möchte zunächst darauf hinweisen das ich im Moment über sehr wenig Zeit verfüge und dadurch die Dokumentation der Verschlüsselung nicht so 100%tig anfertigen kann, wie ich es mir vielleicht wünschen würde. Eine gute Dokumentation kostet in der Regel mehr Zeit als der Softwareentwurf selbst und ich bin gerade damit beschäftigt eine Ausbildung zum Fachinformatiker zu machen und als Teilzeitstudent an einer FernUni im Studienfach Informatik eingeschrieben (fragt nicht wiso beides). Ausserdem möchte ich noch Java (Applets, Anwendungen und Servlets erstellen) lernen, nachdem ich mich bereits in PHP und MySQL eingearbeitet habe. Ich kann nur jedem empfehlen die entsprechenden Seiten zu besuchen und möchte die Gelegenheit nutzen diese Seiten zu empfehlen, die mir sehr geholfen haben:

Very Simple Crypt stellt die Implementierung eines Verschlüsselungsalgorithmus dar. Der Algorithmus wird weiter untern genau erklärt, VSC ist eine Implementation und wurde in Java realisiert. Der Name kommt durch die Einfachheit des zugrundeliegenden Algorithmus zustande, denn der Algorithmus verzichtet vollkommen auf komplexe Mathematik. Es werden jediglich sehr einfache mathematische Operationen wie NOT (Negierung / Einerkomplementär), XOR (Entweder-Oder Verknüpfung), Addition modulo 2¹⁶ und eine SBOX (Switch-BOX, Quelldatenvertauschung) benutzt. Sämtliche Opertationen sind 16-Bit Operationen, liefern also ein 16-Bit Ergebnis und benutzen 16-Bit Operanten, wobei die einzelnen Teilschlüssel jedoch 18-Bit Schlüssel sind.

Für VSC wurde eine Implementation in Java gewählt, weil der Algorithmus plattformunabhängig sein sollte und dies auch ist. VSC kann theoretisch auch ohne Probleme in einer anderen Programmiersprache realisiert werden, dies wird durch die Plattformunabhängigkeit des zugrundeliegenden Algorithmus garantiert. Java wurde aus verschiedenen Gründen gewählt. Zum Einen ist Java eine wirklich plattformunabhängige Sprache und zum Anderen gewinnt Java im Internet und in der PC-Welt im Allgemeinen mehr und mehr an bedeutung. Ich persönlich denke das Java sich zum Nachfolger von C/C++ entwicklen wird, es ist eine konsequent objektorientierte Sprache und bietet viele Vorteile im Vergleich zu anderen Programmiersprachen. Zum Anderen ist der Algorithmus auf diese Art und Weise sehr leicht im Internet einsetzbar und er ist theoretisch sogar in Java-Script zu realisieren.

Um die Dokumentation der Implementation, sprich die Dokumentation von VSC (Very Simple Crypt) einzusehen, klicken Sie hier. Diese Dokumentation wurde durch das Tool "javadoc" erzeugt. Wenn Sie den Quellcode downloaden möchten, dann klicken Sie bitte hier. Bitte beachten Sie das sich die Implementation noch in der Alphaphase befindet, die Software kann noch bedeutende Mängel enthalten und wird mit Sicherheit noch gravierende Änderungen erfahren. Betrachten Sie dies mehr als Demoversion, denn als wirkliches Release !

Dieser Algorithmus hat seinen Namen aus Gründen bekommen, die ich hier nicht weiter erwähnen möchte. Ich möchte jedoch zunächt auf ein paar Einzelheiten der Entwicklung des Algorithmus eingehen, bevor ich den Algorithmus selbst und seine Implementation am Beispiel von Java vorstelle. Der Hintergedanke dieses Algorithmus war einen möglichst einfachen, schnellen und definitiv plattformunabhängigen Algorithmus zu entwickeln, der vor allem Frei von Rechten ist. Aus diesem Grund kann ich jedem Interessierten zunächt die freudige Mitteilung machen das der Algorithmus weder Patentiert ist, noch von mir patentiert werden wird. Der Algorithmus darf auch kommerziell verwendet werden und ohne Linzengebühren oder sonstige Beschränkungen eingesetzt werden. Ich stelle diesen Algorithmus und seine Beispielimplementierung (VSC) hiermit unter die GPL (General Public License, General Public License im Textformat).

Der Grundgedanke der Entwicklung war einen möglichst sichereren Algorithmus ohne komplexe oder schwer verständliche mathematische Elemente bzw. Operationen zu entwickeln. Er sollte von jedermann realisierbar und einsetzbar sein, auch ohne tiefgreifende mathematische Kenntnise zu besitzen. Besonders auf eine einfache Implementation wurde dabei geachtet. Der Algorithmus ist jedoch kein sog. Public-Key Algorithmus, es handelt sich um ein einfaches symmetrisches Verschlüsselungsverfahren (für Public-Key Verfahren verweise ich an dieser Stelle auf PGP). Der Algorithmus sollte es ermöglichen eine sichere Verbindung zwischen zwei Kommunikationspartnern zu ermöglichen, unter der Vorraussetzung das beide Partner bereits über einen sicheren Kommunikationsweg ein Kennwort ausgetauscht haben.

Ich möchte an dieser Stelle noch kurz meinen besonderen Dank an meine Eltern richten, die mich immer sehr viel unterstüzt haben. Außerdem möchte ich noch einen weiteren besonderen Gruß an Mareile Basler aussprechen. Zu guter Letzt möchte ich noch Grüße an folgende Personen richten:

Der Elieram Verschlüsselungsalgorithmus ist ein symmetrischer Blockalgorithmus. Dies bedeutet das der Algorithmus Datenblöcke gleicher Größe ver- und entschlüsselt und die Ver- und Entschlüsselung mit ein und dem selben Schlüssel stattfinden. Es ist also kein Public-Key Algrotihmus, bei welchen zum Verschlüsseln ein anderer Schlüssel als zum Entschlüsseln verwendet wird. Dies bedeutet das der Schlüssel von beiden Parteien geheim gehalten werden muß, daher eignet er sich nur für bestimmte Situationen. Das Problem ist das man theoretisch, um wirklich sicher zu sein, mit jedem Kommunikationspartner einen eigenen Schlüssel auf einem sicheren Kommunikationsweg austauschen muß. In der Praxis kann der Algorithmus jedoch mit einem langsamen Public-Key-Verfahren in Kombination verwendet werden. So kann z.B. mittels einer durch Public-Key Algorithmen geschützten Kommunikation ein temporärer Schlüssel ausgetauscht werden, welcher nur für diese eine Kommunikation gilt. Doch dies führt an dieser Stelle zu weit.

Ich möchte jetzt den Algorithmus erklären und später nochmal auf die theoretische Sicherheit des Algorithmus zu sprechen kommen. Der Algorithmus verschlüsselt immer Datenblöcke der Größe 64 Byte. Diese Datenblöcke werden in 32 Worte (32 mal 16 Bit Zahlen) eingeteilt und von Data₀ bis Data₃₁ durchnummeriert. Die Eingangsdaten enthalten auch wieder nach dem Ende der Verschlüsselung die Ausgangsdaten. Interessant ist vielleicht noch zu Wissen das der Algorithmus immer mit einer Schlüsseltiefe von 4608 Bit arbeitet !

Aus dem Kennwort des Benutzers werden verschiedene Schlüssel erzeugt die dann der Datenverschlüsselung dienen. Dieses Verfahren hat den Vorteil das kein Key-File (eine Datei in welcher der Schlüssel gespeichert werden muß) nötig ist. Der Schlüssel kann an jedem beliebigen Computer generiert werden, wenn der Benutzer sein Kennwort kennt. Die Mindestlänge eines Kennwort beträgt 12-Zeichen. Erlaubt sind dabei nur folgende Zeichen:

Die Zeichen 'a' bis 'z'
Die Zeichen 'A' bis 'Z'
Die Ziffern '0' bis '9'
Das Leerzeichen
Der Punkt als Sonderzeichen

Diese Zeichen werden anschließend in Zeichenschlüssel umgerechnet, dabei werden die Zeichen 'A' bis 'Z' in die Zahlen 0 bis 25 umgerechnet, die Zeichen 'a' bis 'z' in die Zahlen 26 bis 51, die Ziffern '0' bis '9' in die Zahlen 52 bis 61, daß Leerzeichen in die 62 und der Punkt in die 63. Wenn im Kennwort des Benutzers Zeichen enthalten sind, welche nicht der obrigen Spezifikation entsprechen, dann sollten diese Zeichen einfach ignoriert und nicht beachtet werden.

Dadurch ergeben sich exakt 64 Möglichkeiten für jeden Zeichenschlüssel. Anders ausgedrückt ergeben sich dadurch 2⁶ Möglichkeiten bzw. jede Stelle des Kennwortes entspricht 6 Bit. Aus diesen Zeichenschlüsseln werden dann die Teilschlüssel erzeugt. Der Gesamtschlüssel besteht aus 256 Teilschlüsseln a 18 Bit, damit ein solcher Schlüssel nur aus den Eingaben des Benutzers entsteht müßte der Benutzer ein Kennwort bestehend aus 768 gültigen Zeichen eingeben. Dies kann jedoch keinem Benutzer zugemutet werden, aus diesem Grund muss das Kennwort des Benutzers mindestens 12 Zeichen lang sein und darf bis zu 768 Zeichen enthalten. Optimal sind natürlich 768 Zeichen, auch wenn niemand 768 Zeichen eingeben möchte, so sollte das Kennwort dennoch so lang wie nur möglich sein. Die vom Benutzer nicht eingegeben Zeichen müssen dann berechnet werden, zu diesem Zweck kommt folgender Algorithmus zum Tragen:

Zunächst wird das vom Benutzer eingegebene Kennwort in 18-Bit Teilschlüssel umgerechnet. Dabei werden jeweils drei eingegebene Zeichen zu einem Teilschlüssel zusammengesetzt. Die 6-Bit Zeichenschlüssel werden als SKey₀ bis SKey_n bezeichnet, wobei n maximal 767 sein kann. Die 18-Bit Teilschlüssel werden als Key₀ bis Key₂₅₅ gekennzeichnet. Das Zusammensetzen funktioniert wie folgend:

Von i = 0 solange gilt (i < (n/3)):

Key_i = (SKey_i*3 << 12) OR (SKey_i*3+1 << 6) OR SKey_i*3+2

Bemerkung: << stellt eine Bitverschiebung um x Stellen nach links dar.

Daraus ergibt sich also ein Schlüssel der 18-Bit lang ist und aus drei Zeichenschlüsseln berechnet wird. Wenn zum Schluß der ersten Schlüsselberechnung nur noch ein oder zwei Zeichen übrig sind, kann kein weiterer Schlüssel daraus berechnet werden, die Zeichen werden ignoriert (man sagt sie sind nicht Signifikant). Nach dem Umrechnen der Zeichenschlüssel (also der Benutzereingaben) sind n-Teilschlüsseln vorhanden, je nachdem wieviel Zeichen der Benutzer als Kennwort eingegeben hat. Solange weniger als 256 Teilschlüssel vorhanden sind, werden aus den vorhandenen Teilschlüsseln nach folgendem Algorithmus neue Teilschlüssel erzeugt. Dabei gilt zu beachten das durch die Anwendung des Algorithmus die Schlüssel mit jedem Durchlauf maximal um 50% vermehrt werden können, unter Umständen muß der folgende Algorithmus also mehrfach hintereinander angewendet werden bis die benötigten 256 Teilschlüssel zur Verfügung stehen. Auf jeden Fall sollen nicht mehr als 256 Teilschlüssel erzeugt werden.

Von i = 0 solange (i < (n/2)) berechne:

Key_n+i = Key_i XOR Key_(n-1)-i

Es gilt:
n = Anzahl der vorhandenen Teilschlüssel, wobei für n-Schlüssel die Schlüssel Key₀ bis Key_n-1 existieren
Hinweis: Das es sich um 18 Bit Schlüssel handelt sollten die erzeugten Teilschlüssel in 32 Bit Variablen gespeichert werden, dadurch werden die führenden Bits jedoch mit ungültigen Werten gefüllt. Aus diesem Grund sollten alle erzeugten Schlüssel am Ende nocheinmal mit dem hexadezimalen Wert 0x3FFFF UND-Verknüpft werden (es bleiben saubere 18-Bit übrig).

Bei der Verschlüsselung werden immer 512-Bit, sprich 64 Byte auf einmal im Block verschlüsselt. Dieser Block wird mit den 256 Teilschlüsseln verknüpft und zwar mehrfach. Die 64 Datenbytes werden wie bereits weiter oben erwähnt in 32 Eingangsdaten a 16-Bit zerlegt. Diese Daten werden im Folgenden als Data₀ bis Data₃₁ bezeichnet und stellen sowohl Eingangs- wie auch Ausgangsdaten dar.

Die Teilschlüssel sind zwar 18 Bit Schlüssel, sie werden jedoch in einen 2-Bit Befehlsschlüssel (Key_cmd, Bit 16 und 17) und in einen 16-Bit Schlüssel (Key_crypt, Bit 0 bis 15) zerlegt. Der Key_cmd entscheidet über die Art der Verknüpfung und stellt somit einen Befehl da. Dabei entspricht eine 0 dem Encrypt_NOT, eine 1 dem Encrypt_XOR, eine 2 dem Encrypt_ADD und eine 3 dem Encrypt_S-BOX.

Die Daten werden in Runden verschlüsselt wobei jede Runde aus 8 Teilrunden besteht. Die 256 18-Bit Teilschlüssel werden dabei in 8 x 32 Teilschlüssel gruppiert, von Key¹₀ bis Key⁸₃₁. Die Gruppierung erfolgt so das die Teilschlüssel 0 bis 32 die ersten 32 Teilschlüssel der ersten Teilrunde darstellen, die nächsten 32 die der zweiten Runde usw.. In jeder Teilrunde werden die Daten (Data₀ bis Data₃₁) mit den Teilschlüsseln (Key^Teilrunde₀ bis Key^Teilrunde₃₁) verknüpft. Die Art der Verknüpfung entscheidet dabei der Key_cmd des Teilschlüssels. Es gilt also für jede Teilrunde (o ^= Verknüpft mit):

Data_i = Data_i o Key^Runde_i

oder anders gesagt:

Data_i = Data_i o Key_{Teilrunde*32+i}

Jeder Datenblock durchläuft acht solcher Teilrunden. Dabei werden nach jeder Teilrunde die Teilschlüssel verändert, sprich rotiert. Zunächst wird jeder Teilschlüssel intern um 5 Bit nach links rotiert, anschließend werden die gesamten Teilschlüssel um 7 Teilschlüssel nach rechts rotiert. Dadurch entstehen nach jeder Runde neue Teilschlüssel mit neuen Key_cmd und Key_crypt Teilen.

Hinweis: Die Rotation ist relativ einfach, es ist jedoch eine Eigenart dieses Algorithmus das darauf zu achten ist, daß die Rotation mit den Originalschlüsseln geschieht, denn zum Entschlüsseln wird der hier veränderte Gesamtschlüssel (spricht die rotierten Teilschlüssel) benötigt !

Zur Entschlüsselung kann im Prinzip genau wie bei der Verschlüsselung vorgegangen werden, nur regressiv. Außerdem muß zur Entschlüsselung natürlich als Schlüssel der rotierte Schlüssel der Verschlüsselung vorliegen. Dabei ist es natürlich auch einfachst möglich aus einem unrotierten (aus dem Benutzerkennwort zur Verschlüsselung gebildeten) Schlüssels einen solchen rotierten Schlüssel zu erzeugen. Der entsprechende Schlüssel muß nur zunächst 8 mal um 5 Bit nach links rotiert und anschließend um 7 Schlüssel nach rechts rotiert werden (siehe Schritt 2, Anwenden des Algorithmus). Dabei ist noch darauf zu achten das die Addition modulo 2¹⁶ einen Sonderfall darstellt (siehe Anhang) und entsprechend behandelt werden muß.

Über die Sicherheit dieses Algorithmus ist noch absolut nichts bekannt was auch logisch ist, weil ich den Algorithmus hier zum Ersten mal veröffentliche. Es gibt jedoch ein paar Dinge die mir bereits aufgefallen sind, so gibt es definitiv schwache Schlüssel. Alle Schlüssel die aus weitgehend gleichen Bits bestehen sind schwache Schlüssel, dabei sind vor allem Benutzereingaben entscheidend. Also alle Schlüssel die zu mehr als 90% aus einer Bitart (0 oder 1) bestehen. Besonders schwach sind also Schlüssel wie z.B. "AAAAAAAAAAAA" oder "............". Aber auch Schlüssel wie "ABABABABABAB" oder "9.9.9.9.9.9.", also Schlüssel die nur aus Zeichen bestehen die eine ähnlichen Bitkombination besitzen. Diese Schwächen sind mir durchaus bewußt, doch wurde der Algorithmus so entworfen das die entsprechenden Schwächen eigentlich nicht zum Tragen kommen sollten. Die meisten Benutzer werden wohl sehr viele Kleinbuchstaben und nur wenige Großbuchstaben, Sonderzeichen oder Ziffen in ihre Kennwörter einbauen. Dementsprechend wurden die Kleinbuchstaben von der Zahlenrepräsentation entsprechend in den wichtigsten Zahlenbereich gelegt. Dem folgen die Ziffern, am ungünstigsten dürften das Sonderzeichen '.', das Leerzeichen und die Großbuchstaben liegen.

Aus diesem Grund habe ich eine Methode in die Schnittstelle integriert die ein Kennwort auf Schwächen prüft und gegenenfalls das Kennwort als Schwach ausweist. Die Methode überprüft zur Zeit nur auf die von mir oben bekannten Schlüssel, kann jedoch jederzeit an neue Schwächen angepaßt werden.

Ich empfehle einfach bei der Kennwortwahl sehr lange Kennwörter mit mindestens 24 Zeichen zu wählen, besser wären 48 Zeichen. Es ist auch möglich sich einen Merksatz als Kennwort zu wählen. Man könnte auch einen Paragraphen aus einem Gesetzbuch als Kennwort auswählen, der Phantasie sind keine Grenzen gesetzt. Am Besten ist natürlich eine Kombination aus Zahlen und Zeichen, sowie die Verwendung von Groß- und Kleinschrift. So könnte man z.B. den Satz "Meine Mutter hat am 24.08.1950 Geburtstag. Mein Vater hat am 14.09.1947 Geburtstag. Meine Schwester hat am 01.11.1987 Geburtstag und ich habe am 19.04.1984 Geburtstag." (166 Zeichen) als relativ gutes und sicheres Kennwort bezeichnen, auch wenn viele Leerzeichen verwendet werden ;-).

Ich möchte jetzt noch einmal auf einen sog. Brute-Force Angriff eingehen, d.h. der Versuch ein Kennwort zu erraten. Wenn jediglich die Mindestanzahl an Zeichen (12 Zeichen) benutzt wird ist ein reines durchprobieren aller Kennwörter mit heutigen Computern nicht mit einem angemessenen Zeitaufwand möglich, geschweige denn das Durchprobieren aller Schlüssel (bei den Schlüsseln gibt es 2⁴⁶⁰⁸ Möglichkeiten !!!). Selbst wenn bekannt ist das ein Schlüssel aus 12 Zeichen besteht, dann ergeben sich daraus folgende Möglichkeiten:
Jedes Zeichen kann 64 verschiedene Zustände enthalten und da wir 12 Zeichen haben gibt es 64¹² Möglichkeiten. Das sind 4,722,366,482,869,645,213,696 Möglichkeiten oder anders gesagt 4,722,366,482,869 Milliarden verschiedene Möglichkeiten. Selbst wenn wir einen Supercomputer hätten der eine Billionen (1000 Milliarden) Kombinationen pro Sekunde ausprobieren könnte, dann würden wird 4,722,366,482 Sekunden oder 78,706,108 Minuten, bzw. 1,311,768 Stunden, bzw. 54,657 Tage oder 149 Jahre brauchen, um auf jeden Fall den Schlüssel gefunden zu haben. Selbst wenn wir den Schlüssel schon nach einem hundertstel (1/100) der Zeit finden, weil wir alle schwachen Schlüssel ausschließen und viel Glück haben, dann wird die Information wohl kaum mehr von Interesse sein, sie ist dann 1,5 Jahre alt. Mal davon abgesehen das 1,000 Milliarden Kombinationen pro Sekunde utopisch sind, braucht man nur die Schlüssellänge auf 15 Zeichen zu erhöhen und ein Brute-Force Angriff dürfte vollkommen sinnlos sein.

Es bleiben also zum Angriff auf diesen Algorithmus nur kryptologische Methoden, Verfahren und Ansätze. Mir ist bis heute jedoch, mal von den schwachen Schlüsseln abgesehen, kein Angriffspunkt bekannt und ich bin schon schwer gespannt ob es jemand gibt, der einen solchen findet. Sobalt jemand einen zuverläßigen Angriffspunkt gefunden hat möge er mir bitte eine E-Mail an Elieram.Algorithmus@alexander-weber.net senden.

Die Ver- bzw. Entschlüsselung mittels Addition modulo 2¹⁶ ist ebenfalls relativ einfach. Mathematisch gesehen müßte eigentlich der Schlüssel zum Entschlüsseln negiert werden (mit minus eins multiplizieren), dann kann die selbe Funktion zum Ver- und Entschlüsseln benutzt werden. Ich finde es jedoch etwas verschwänderisch, aus diesem Grund empfehle ich einfach zwei unterschiedliche Funktionen für das Ver- und Entschlüsseln zu schreiben (eigentlich sowieso ein muß), beim Verschlüsseln kann dann einfach eine Subtraktion modulo 2¹⁶ durchgeführt werden, was schneller ist als eine vorherige Multiplikation mit minus eins. Es gibt auch noch andere Wege, z.B. das Bilden des Zweierkomplementär, dann kann ebenfalls bei der Addition modulo 2¹⁶ geblieben werden, ich verwende jedoch den von mir empfohlenen Weg, jedem das seine und mir das meine.

Verschlüsselung: Data_i = (Data_i + Key_j) % 2¹⁶
Entschlüsselung: Data_i = (Data_i - Key_j) % 2¹⁶

Very Simple Crypt (VSC)

Einleitung Allgemein

Einleitung zu VSC

Der Elieram Algorithmus

Grundlagen des Elieram Algorithmus

Der Verschlüsselungsalgorithmus

1. Schritt: Die Schlüsselgenerierung aus dem Kennwort

2. Schritt: Anwenden des Algorithmus (Verschlüsselung)

3. Schritt: Anwenden des Algorithmus (Entschlüsselung)

Sicherheit des Elieram Algorithmus

Anhang A: Ver- und Entschlüsselung mittels NOT (Encrypt_NOT)

Anhang B: Ver- und Entschlüsselung mittels XOR (Encrypt_XOR)

Anhang C: Ver- und Entschlüsselung mittels Addition modulo 2¹⁶(Encrypt_ADD)

Anhang C: Ver- und Entschlüsselung mittels S-BOX (Encrypt_S-BOX)