Alice und Bob sind es leid, zum Austausch ihrer geheimen Nachrichten sich immer mit einzelnen Bits beschäftigen zu müssen. Denn schon ein einzelnes Bit könnte ausreichen, ihre Geheimnisse zu verraten. Seit Jahrhunderten haben die Kryptographen ja auch nur ganze Zeichen für ihre Verschlüsselung verwendet. Das müsste doch auch noch heute möglich sein, vor allem unter Einsatz moderner Techniken. Sie erinnern sich einer alten Methode, nach der die Partner ein bestimmtes Buch auswählen und dann durch Hinweise auf einzelne Textstellen den geheimen Text zusammenstellen (z.B.: a = Seite 27, Zeile 12, Buchstabe 9, b = Seite 19, Zeile 4, Buchstabe 21, ... oder einfacher als Zahlencode: 27,12,09 / 19,04,21 / 14,23,13). Ein Angreifer kann die Nachricht natürlich nur dann entziffern, wenn er auch das vereinbarte Buch (Schlüssel) besitzt.
Etwas Vergleichbares müsste sich auch mit folgenden Schritten erreichen lassen:
1. Beide Partner - Sender und Empfänger - erzeugen einen identischen
kryptographischen Mechanismus, der in seiner Funktion dem Buch
entspricht. Das könnte ein mehrdimensionales Array (Matrix) sein,
in dem alle Klarbuchstaben an geheimen aber wohl definierten
Positionen gespeichert sind.
2. Ein Klarbuchstabe wird in dem Array gesucht und mit seiner Position
(x,y,z) gekennzeichnet. Diese Koordinaten werden einem getrennten
Ordnungssystem (Transfer-Alphabet) als Zeiger ("pointer") zugeordnet
und als "Chiffretext" zum Empfänger geschickt.
3. Der Empfänger sucht den erhaltenen Zeiger im Transfer-Alphabet,
stellt mit den Koordinaten (x,y,z) die Position in seinem identischen
Array (Matrix) fest und findet so den ursprünglichen Klarbuchstaben.
B. Grundlegende Idee des Verfahrens
Für eine Verschlüsselung müssen sowohl ein Klartext-Alphabet als auch ein Chiffretext-Alphabet (Transfer-Alphabet) vorhanden sein. Als einfaches Beispiel die folgenden Daten:
Klartext-Alphabet (64 Zeichen):
abcdefghijklmnopqrstuvwxyz 01234
56789/ABCDEFGHIJKLMNOPQRSTUVWXYZ
Das Klartext-Alphabet mit 64 Zeichen [#1] wird in einer zweidimensionalen Matrix 8x8 (Array)
gespeichert und in jeder Verschlüsselungsrunde einer gründlichen
Durchmischung (Permutation) unterzogen:
0 1 2 3 4 5 6 7
0 m 7 b G 4 h L j
1 x E l 0 B q k 1
2 d A 6 R i z I c
3 K o N 5 w O r M
4 W 2 / u 9 f a Q
5 v P F 3 y V p
6 T 8 t U H n Y J
7 g C Z D s X e S
Das Chiffretext-Alphabet (Transfer-Zeichen) mit 32 Zeichen besteht unabhängig vom Klartext-Alphabet
aus völlig anderen Zeichen:
ß $ :
Die Zeichen werden in einem Vektor (Array) gespeichert und ebenfalls für jede Verschlüsselungsrunde
gründlich durchmischt (Permutation):
Chiffretext-Alphabet (32 Zeichen):
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
$
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
ß :
Für den Klartext "Kryptographie" ergibt sich dann folgender Basistext:
K r y p t o g r a p h i e
30 36 55 57 62 31 70 36 46 57 05 24 76
Da das Klartext-Alphabet aus 64 (8x8) Zeichen besteht, werden die einzelnen Zeichen
vom Zahlensystem zur Basis 8 auf binäre Werte (6-bit Sequenzen) umgerechnet
Bit-Konversion:
Basis 8: 30 36 55 57 62 31 70 6-bit Sequ: 011000 011110 101101 101111 110010 011001 111000 Basis 8: 36 46 57 05 24 76 6-bit Sequ: 011110 100110 101111 000101 010100 111110Die Folge der 6-bit Sequenzen teilt das Verfahren in 5-bit Sequenzen auf, deren Werte als Index das zugehörige Zeichen aus dem Chiffretext-Alphabet holen.
5-bit Sequ: 01100 00111 10101 10110 11111 10010 01100 11110 Indexwerte: 12 7 21 22 31 18 12 30 5-bit Sequ: 00011 11010 01101 01111 00010 10101 00111 ..... Indexwerte: 3 26 13 15 2 21 7 ..Die mit den Indexwerten im Chiffretext-Alphabet gefundenen Zeichen bilden den Transfertext.
Chiffretext: ..
12 7 21 22 31 18 12 30 3 26 13 15 2 21 7 ..
Beim Empfänger erzeugt das Verfahren identische Klartext- und Chiffretext-Alphabete.
Die Indizes der empfangenen Transfer-Zeichen im Chiffretext-Vektor (Array) führen
zu den Klartext-Zeichen im permutierten Klartext-Alphabet. Als einziges Problem bleibt die
Aufgabe, einen Mechanismus zu finden, der sowohl beim Sender als auch beim Empfänger
einen identischen Ablauf des Verfahrens bewirkt.
Wenn Sie das grundlegende Prinzip selbst einmal ausprobieren möchten, können Sie sich
zwei kleine selbstextrahierende DEMO-Programme - "R6Cipher.exe
und "R7Cipher.exe" auf Ihren Rechner holen. Ihre Systemdateien
werden dadurch nicht berührt.
C. CypherMatrix als kryptographische Basis Funktion
Aus den vorstehenden Überlegungen ist das Verschlüsselungsverfahren CypherMatrix® (Bezeichnung vom Autor) entstanden. Über Verschlüsselungen hinaus zeigt sich das CypherMatrix Verfahren als universielle Basis Funktion (CBF), die in vielen Bereichen der Kryptographie eingesetzt werden kann.
Eine geheime Start-Sequenz (PassPhrase) als gemeinsamer Schlüssel
bei Sender und Empfänger und kollisionsfreie Einweg-Funktionen generieren
die CypherMatrix als einen - bei Sender und Empfänger - identischen kryptographischen Mechanismus.
Eingaben sind alle Bit Sequenzen (insbesondere 8-Bit der 256 Zeichen des erweiterten ASCII-Zeichensatzes)
und Ausgaben unabhängige Alphabete von jeweils 128 Chiffretext Zeichen. Das Verfahren verwendet nur
Byte-Technologie, einfache Mathematik und Modulo-Rechnung sowie Umrechnung von Zahlensystemem
(Basis 2 bis zur Basis 256). Sie können einen kleinen Eindruck von dem Generator im folgenden Schaubild
gewinnen:
1. General-Schlüssel: Start-Sequenz
Die kryptographische Basis Funktion - CypherMatrix - startet mit einer leicht zu merkenden Start-Sequenz von optimal 42 Bytes (Passphrase). Die Start-Sequenz initialisiert und steuert das gesamte Verfahren. Einige Beispiele:
7 Nordlichter wandern über den großen Belt
Im Maschpark laufen die Eisbären an der Leine
Kangaroos jumping in the hills of Amarillo
The flying Dutchman was never in New Zealand
Die Passphrasen sind leicht zu behalten, sie brauchen nicht aufgeschrieben zu werden und
sind im Hinblick auf ihre Länge auch keinem Wörterbuchangriff ausgesetzt.
Ein Angreifer kann auch nicht mit Erfolg versuchen, Teile eines Schlüssels getrennt
und nacheinander zu analysieren, da die Schlüssel-Sequenzen nur in einem
Durchgang als Ganzes angesprochen werden können. Die Änderung auch
nur eines einzigen Bits sperrt die Funktion und führt zu völlig anderen Ergebnissen:
Start Sequenz 1: Mit dem Hut in der Hand durch's ganze Land
d = 0110 0100
Hashwert Basis 16: 1FF04E85F82160
Hashwert Basis 62: fAn0h7aL2
Start Sequenz 2: Mit dem Hut in der Hand durch's ganze Lane
e = 0110 0101
Hashwert Basis 16: 204D5AC8A6EFC1
Hashwert Basis 62: fdgBcvQ2b
(Hashwerte sind mit dem Programm "CMXHash.exe" ermittelt)
Mit der Start-Sequenz initialisieren Sender und Empfänger zwei kollisionsfreie Einweg-Hash-Funktionen [#2]. Aus den Elementen des erweiterten ASCII-Zeichensatzes von 256 Zeichen werden ein permutiertes Array mit 16x16 Zeichen (CypherMatrix) und verschiedene Steuerungsparameter erzeugt. Die Funktion stellt kryptographisch ein "hartes Problem" dar [#3]. Es gibt keine Möglichkeit retrograd auf die Eingangs-Sequenz zu schließen. Wer die Matrix nicht rekonstruieren kann, hat auch keinen Zugriff auf die Funktionen des Verfahrens.
Die folgende Übersicht veranschaulicht die Zusammenhänge:
Der "Generator" kann eigenständig (z.B. Berechnungen von Hashwerten und Bit- und Byte-Generatoren) oder in Verbindung mit einem Codierbereich für Verschlüsselungen eingesetzt werden. In jeder Runde werden eine permutierte CypherMatrix und die Parameter Variante, Alpha, Beta, Gamma, Delta und Theta neu erzeugt zur Steuerung verschiedener Verfahrensschritte. In jeder Runde entnimmt das Verfahren der Matrix die folgenden Bytefolgen:
1. Ein unabhängiges Chiffretext-Alphabet mit 128 Zeichen
(Array 0...127),
2. einen Block-Schlüssel mit wahlweise 35, 42, 49, 56, 63 oder
70 Zeichen,
3. einen Matrix-Schlüssel mit 42 Zeichen als >Start-Sequenz< für
die nächste Verfahrensrunde und/oder
4. alternativ sämtliche Elemente der CypherMatrix als finalen Hashwert
oder als "Byte stream" für Datendateien in unbegrenzter Länge.
Der Empfänger erzeugt mit derselben Start-Sequenz eine inhaltsgleiche CypherMatrix,
identische Steuerungsparameter und dasselbe Chiffretext-Alphabet. Die Start-Sequenz ist die einzige Eingabe,
die den gesamten Ablauf des Verfahrens steuert, sowohl beim Sender als auch beim Empfänger.
2. Kollisionsfreie Einweg-Hashfunktionen
Ein Verfahrens-Zyklus arbeitet in vier Stufen:
1. Erweiterung der Eingabe-Sequenz zu einem positions gewichteten
Zwischen-Ergebnis (Hk), aufgebaut auf einer Hash-Konstante (Ck),
um Kollisionen zu vermeiden,
2. Hochrechnung der Eingabe-Sequenz durch Multiplikation jedes
einzelnen Zeichens zu einer einmaligen Hash-Funktions-Reihe
von 160 bis 2400 Zeichen (expansion),
3. Verdichtung der Hash-Funktions-Reihe durch MODULO 256 zu einem Array
BASIC-VARIATION von 256 Zeichen (contraction) und
4. dreifache Permutation der BASIC-VARIATION zur Generierung
der CypherMatrix (16x16 Elemente) als abschließendes Ergebnis.
Der Vorgang wiederholt sich in Klartext-Intervallen von wahlweise 7 bis 70 Bytes (Vielfaches von 7),
insbesondere 63 Zeichen. An bestimmter Stelle - durch Steuerungsparameter Gamma definiert -
entnimmt das Verfahren der CypherMatrix eine digitale Folge von 42 Bytes "Matrix-Schlüssel,
die als neue Start-Sequenz für die nächste Runde auf den Eingang zurückgeführt
wird ("loop").
a) Erweiterung der Start-Sequenz
Eine Start-Sequenz mit der Länge (n) ist eine Folge von definierten Zeichen (Bytes):
Sequenz = a1 a2 a3 ... ai ... anFür die folgenden Erläuterungen wählen wir die Start-Sequenz:
Im Folgenden bedeuten:Baron Münchhausen reitet über den Bodensee
n = Länge der Eingangs-Sequenz
ai = Element der Eingang-Sequenz (erweiterter
ASCII-Zeichensatz mit 256 Elementen)
pi = Position in der Eingangs-Sequenz
Hk = positionsgewichteter Hash-Wert
Um der Sequenz univalent einen Wert Hk zuzuordnen, muss jedes Byte (ai) mit einem Wert
(Index) definiert und die einzelnen Bytes müssen in geeigneter Weise miteinander verknüpft werden.
Die Bit-Struktur der Eingangs-Sequenz ist eine digitale Folge von "0" und "1". Aufgeteilt in 8-bit Sequenzen (binäre Zahlen 0 bis 255)
lassen sich die Werte in dezimalen Zahlen ausdrücken, als Indexwerte dem erweiterten ASCII-Zeichensatzes (null bis 255)
zuordnen und in andere Zahlensysteme (Basis 2 bis zur Basis 256) umrechnen.
Verknüpfung durch Addition:
Hk = a1 + a2 + a3 +... ai +... an
(Die einzelnen Werte für "ai" werden um (+1) erhöht, da sonst der Wert
ASCII-null keine Berücksichtigung findet)
n
Hk = 
(ai + 1)
i = 1
Hk = 4074
Der so errechnete Wert ist allerdings weit davon entfert als Hash-Wert dienen zu können.
Zur eindeutigen Verknüpfung der Bytes müssen daher weitere Merkmale hinzukommen.
Entsprechend der allgemeinen Aussage, dass jeder Sachverhalt durch Koordinaten für den Gegenstand, den Ort und die Zeit eindeutig bestimmt wird (kartesisches Koordinatensysten: [#22]), muss hier zusätzlich zum Gegenstand (Zeichen: ai) zumindest noch der Ort berücksichtigt werden. Dabei kann als "Ort" die Position (pi) des Zeichens (ai) in der Sequenz dienen. Die Koordinate Zeit ist normalerweise nicht relevant (ti=1), es sei denn zwischen der CPU-Taktfrequenz und bestimmten Bytes besteht eine funktionale Verbindung (eventuell: voice streaming).
In der Funktion wird jedes Zeichen ai der Start-Sequenz positionsgewichtet, indem es mit seinem Ort (pi) in der Sequenz multipliziert wird.
n
Hk = (ai + 1) * pi * ti
i = 1
ti = 1
Damit ist allerdings die Möglichkeit von Kollisionen noch nicht ausgeschlossen.
Eine Kollision bilden unterschiedliche Eingangs-Sequenzen dann, wenn sie auf denselben
Hash-Wert abgebildet werden. Es muss also noch ein Faktor hinzukommen. der alle
Einflussgrößen aufnimmt, die eine Kollision beeinflussen.
Für einen Hash-Wert wird allgemein gefordert [#5]:
a) Die Hash-Funktion muss kollisionsresistent sein und
b) eine Einweg-Funktion darstellen.
Die Ableitung der Hash-Konstante Ck wird in der Pdf-Datei: Bestimmungsfaktoren für Kollisionsfreiheit im Einzelnen erläutert.
Die Konstante Ck ist von der Länge der Hash-Sequenz und vom individuell festzulegenden Anwender Code abhängig. Sie errechnet sich wie folgt:
n = Länge der Start-Sequenz
Ck = [(n - (n/(n-1))) / (n/(n-1) - 1)] + Code
Ck = n * (n - 2) + Code
n = sqrt (Ck + 1 - Code) + 1
Ck = 1681
Code ist eine vom Anwender persönlich wählbare Zahl zwischen 1 und 99, mit der die
Konstante Ck - und damit auch die gesamte Funktion - individualisiert wird.
Folgende Kurve kennzeichnet die Abhängigkeiten der möglichen Anzahl Kollisionen vom Wert der
Konstanten Ck:
Das Verfahren errechnet nunmehr einen positionsgewichteten partiellen Hash-Wert Hk,
der Kollisionen ausschließt:
n
Hk = (ai + 1) * (Ck + pi)
i = 1
Hk = 6935825
n = Länge der Eingangs-Sequenz
ai = Element der Eingang-Sequenz (erweiterter
ASCII-Zeichensatz mit 256 Elementen)
pi = Position in der Eingangs-Sequenz
Ck = Hash-Konstante
Hk = positionsgewichteter Hash-Wert
Der errechnete Wert für Hk
schließt zwar Kollisionen aus, ist aber noch zu niedrig für einen unangreifbaren Hash-Wert.
Um sichere Ergebnisse zu erzielen, wird eine Expansions-Funktion eingeführt, die die Bestimmungsfaktoren auf
eine möglichst große Zahl auffächert, ohne die Eigenschaft der Kollisionsfreiheit zu verlieren.
b) Expansion zur Hash-Funktions-Reihe
Die Expansions-Funktion hat die Aufgabe, die relativ kurzen Eingabewerte (42 Bytes) auf möglichst viele Variable (160 bis 2400 Ziffern, Zeichen) in Form einer Hash-Funktions-Reihe (r: 1...m) zu erweitern. Die Funktion konvertiert die dezimalen Werte der Start-Sequenz in höherwertige Zahlensysteme. Der Umwandlungsfaktor kann individuell von Basis 36 bis zur Basis 96 (erweitert: bis 256) festgelegt werden. In unserem Beispiel ist das Zahlensystem zur Basis 85 gewählt. In anderen Anwendungen wird der Expansionsfaktor alternativ mit Basis 77 verwendet.
Das Verfahren errechnet Hash-Funktions-Reihen (Sr) und den partiellen Hash-Wert Hp nach folgenden Formeln:
n
Sr = (ai + 1) * pi * Hk + ( pi + c + r)
i = 1
m
Hp = Sr
r = 1
n = Länge der Eingangs-Sequenz
pi = Position in der Eingangs-Sequenz
ai = Element der Eingang-Sequenz (erweiterter
ASCII-Zeichensatz mit 256 Elementen)
Sr = Ergebnis der Expansionsrechnung für Reihe r
r = Reihe r
m = Anzahl der Reihen r
c = Anwender Code
Hk = positionsgewichteter Hash-Wert
Hp = partieller Hash-Wert
Expansionsbasis: 85
digit: Zahl im Zahlensystem zur Basis 85
Reihe: Hash-Funktions-Reihe
Das gewählte Zahlensystem zur Basis 85 hat folgende Ziffern:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefg
hijklmnopqrstuvwxyz&#@{|}
(definiert vom Autor, nicht standardisiert)
Für die gewählte Start-Sequenz berechnet das Verfahren folgende Funktions-Werte:
Hash Konstante (Ck): 1680 + 1 = 1681
positionsgewichteter Wert (Hk): 6935825
partieller Hash-Wert (Hp): 606406116520
Gesamt-Hash-Wert (Hk+Hp): 606413052345
Aus den Hash-Werten gewonnene Steuerungsparameter:
Variante: (Hk MOD 11)+1 = 7 Beginn Rückumwandlung (86->Dez)
Alpha : ((Hk+Hp) MOD 255)+1 = 91 Beginn Chiffretext-Alphabet
Beta : (Hk MOD 169)+1 = 66 Offset Block-Schlüssel
Gamma : ((Hp+Code) MOD 196)+1 = 150 Offset Matrix-Schlüssel
Delta : ((Hk+Hp) MOD 155)+Code = 31 Beginn dynamische Bit-Folgen
Theta : (Hk MOD 32)+1 = 18 dynamische Zahlenfolgen
In die Berechnung von Gamma und Delta fließt der vom
Anwender gewählte Code ein. Bei gleicher Start-Sequenz können damit bis
zu 99 verschiedene Abläufe initiiert werden. Da die Matrix-Schlüssel
(Eingangs-Sequenz) für jede Runde neu generiert werden, ergeben sich für
die Steuerungsparameter in jeder Runde unterschiedliche Werte.
Die Hash-Funktions-Reihe errechnet sich auszugsweise wie folgt:
char ai+1 pi (ai+1)*pi Hk (ai+1)*pi*Hk si Basis 85
digit
. ... .. .... ....... ........... .......... ......
M 78 7 546 6935825 3786960450 3786960458 ka}
ü 130 8 1040 6935825 7213258000 7213258009 1rFn
n 111 9 999 6935825 6928889175 6928889185 1l&jU
c 100 10 1000 6935825 6935825000 6935825011 1lQ
h 105 11 1155 6935825 8010877875 8010877887 1dW2H
h 105 12 1260 6935825 8739139500 8739139513 1|ZJf3
a 98 13 1274 6935825 8836241050 8836241064 1NTCJ
u 118 14 1652 6935825 11457982900 11457982915 2ngY0
s 116 15 1740 6935825 12068335500 12068335516 2zGM
e 102 16 1632 6935825 11319266400 11319266417 2kjeH
n 111 17 1887 6935825 13087901775 13087901793 2zdPI
. ... .. .... ....... ........... ........... ......
Summe = 606406116520 1puµ7aA
Die Funktion errechnet 251 Ziffern im Zahlensystem zur Basis 85:
1pu|WY58wW7Q3oLhjVs@xisCy#6laQQFHbka}1rFn1l&jU1lQ1dW2H1| ZJf31NTCJ2ngY02zGM2kjeH2zdPIjqO3ZR26y3G4ZoL3e67R420Rt3uySF O4X86A1OqZ15O8DBg4FDZM84deFT5I9JF1kj2B40EH58w5X5zxQN1@6vZ3 un3Hf6Pz&TM5j4fr64Ad6G0C7LhWqk6jtyg6xHKh
(2) Sensitivität der Start-Sequenz
Wird in der Start-Sequenz auch nur ein Bit geändert (das letzte Bit von 1 auf 0 gesetzt), während alle anderen Daten gleich bleiben, zeigt sich die hohe Sensitivität des Verfahrens:
Geänderte Start-Sequenz: Baron Münchhausen reitet über den Bodensed
e = 0110 0101
d = 0110 0100
Hash Konstante (Ck: 1680 + 1 = 1681
positionsgewichteter Wert (Hk): 6934102
partieller Hash-Wert (Hp): 605964240623
Gesamt-Hash-Wert (Hp+Hk): 605971174725
Variante (Hk MOD 11)+1: 11
Alpha ((Hp+Hk) MOD 255)+1: 241
Beta (Hk MOD 169)+1: 33
Gamma ((Hp+Code) MOD 196)+1: 177
Delta ((Hp+Hk) MOD 155)+Code: 131
Theta (Hk MOD 32)+1: 23
Geänderte 251 Ziffern in Zahlensystem zur Basis 85:
1pmg8gX{Q33hejYVYxhWQfziHLQPq}imK1rCui1lx&m31l2Pz1aBnv1|
Vx081JRg2nb12zBW12k{Np2uEOq{l3ZK0e3F}x8L3ewJ418V3ur#y
f4X0HTQ1Oo8Nk5N}v64F54dWE&k5I0m1kh9L4Hf58mlG5zn2&1@3jL3
ugc|{6PoZL5YmPb641u63c7LUV716ji6X6rfjsC
Ein Vergleich mit den Parametern der unveränderten Start-Sequenz zeigt die abweichenden Daten.
Kein einziger Wert stimmt mit den vorhergehenden überein.
Das Beispiel zeigt außerdem, dass die "Start Sequenz" nur insgesamt als Ganzes in einem
Suchvorgang gefunden werden kann, wenn überhaupt. Die Expansion stellt die erste
Einweg-Funktion des Verfahrens dar. Es gibt keinen Weg zurück zur Start-Sequenz.
c) Verdichtung zur GRUND-VARIATION
Um die Funktions-Variablen der Hash-Funktions-Reihe wieder auf dezimale Größen zurückzuführen, werden jeweils seriell drei Ziffern der Reihe in jeder Runde mit MODULO 256 in dezimale Zahlen 0 bis 255 (ohne Wiederholung) umgewandelt und als GRUND-VARIATION in einem Array mit 256 Elementen gespeichert. Bei der Rückumwandlung wird für die Ziffern der Hash-Funktions-Reihe das Zahlensystem zur Basis 86 (Expansionsbasis 85+1) unterstellt. Im Vergleich zum Zahlensystem zur Basis 85 enthält die Basis 86 zwar eine zusätzliche Ziffer, aber das beeinträchtigt den Prozess nicht. Dieser Kontraktionsprozess stellt eine zweite Einweg-Funktion dar. Die Funktion ist nicht umkehrbar und eine Bestimmung der Hash-Funktions-Reihe retrograd ist nicht möglich. Der Kontraktionsprozess kann alternativ auch mit anderen MODULO-Faktoren (2 bis 256, insbesondere 8,16,24,32 und 64) durchgeführt werden.
In Pseudo-Code Darstellung geschieht folgendes:
FOR k=1 TO 256
Zahl = MID$(Reihe, k, 3) dreistellige Zahl Basis 86
CALL SystemNachDez (86, Zahl, Dezimal) Rückumwandlung
Element = (Dezimal MOD 256) Begrenzung auf 0 bis 255
Variation(k)=Element GRUND-VARIATION: 256 Elemente
IF k>1 THEN
n = 0
DO
INCR n
IF Variation(n) = Element THEN
INCR Element
Variation(k) = Element
n = 0
END IF
LOOP UNTIL n = k-1
END IF
NEXT k
Danach ergibt sich für unser Beispiel folgende Entwicklung der Daten:
1pu|WY58wW7Q3oLhjVs@xisCy#6laQQFHbKb......Mit dem Parameter Variante = 7 (Beginn der Rückumwandlung) beginnt die Berechnung an der siebten Position der Hash-Funktions-Reihe:
3 Zahlen dezimal modulo 256
Basis 86
58 37744 112
8w 65762 226
wW 567116 76
wW7 431727 111
W7Q 237300 244
7Q3 54011 251
Q3o 192604 92
3oL 26509 141
oLh 371649 193
... ...... ...
In der ersten Runde entsteht folgendes Array Variation(k) mit 256 Elementen:
GRUND-VARIATION (256 Elemente)
Verteilung der Elemente
112 226 076 111 244 251 092 141 193 083 177 013 220 000 211 254
138 096 093 033 053 052 079 070 014 230 243 067 055 218 082 184
081 057 199 119 194 113 022 203 027 225 236 221 154 010 165 061
247 168 202 158 133 195 227 204 126 062 127 205 147 222 183 181
135 086 051 167 071 239 020 201 104 228 040 128 210 233 087 206
237 015 252 023 131 255 130 149 088 032 229 231 136 054 159 139
217 207 164 099 134 137 064 190 008 132 140 016 187 142 017 153
223 094 124 240 208 084 102 060 232 073 209 143 063 185 036 234
018 114 219 174 026 120 155 045 089 041 253 019 196 021 144 145
029 146 115 238 212 169 224 108 152 077 160 213 059 241 001 028
148 150 095 161 214 248 235 151 098 162 103 129 116 024 004 072
156 056 242 097 163 166 117 091 080 046 065 100 049 007 245 106
066 197 107 030 105 173 090 186 157 246 170 002 003 069 012 068
171 123 101 172 175 109 074 005 025 110 058 009 006 075 078 085
118 121 200 122 125 176 038 215 042 178 216 031 249 179 180 182
188 189 191 250 043 011 034 035 037 039 044 047 048 050 192 198
Die intensive Verteilung der Elemente hängt von der Länge der Start-Sequenz
ab. Bei Längen von weniger als 36 Bytes ergeben sich möglicherweise einige
Abschnitte mit aufeinander folgenden Werten. Das könnte die Intensität der Permutation
beeinträchtigen.
d) Dreifache Permutation zur CypherMatrix
Mit der Start-Sequenz in der ersten Runde, bzw. dem Matrix-Schlüssel ab der zweiten und weiteren Runden, und den zwei Einweg-Funktionen (Expansion und Kontraktion) erzeugt das Programm das Array Variation(k) mit 16x16 Elementen, das hier als GRUND-VARIATION bezeichnet wird.
f: Start-Sequenz ---> GRUND-VARIATIONDie GRUND-VARIATION ist eine eindeutige nicht umkehrbare Abbildung der Start-Sequenz bzw. des fortgeschriebenen Matrix-Schlüssels.
In der CypherMatrix (16x16) werden alle Zeichen des erweiterten ASCII-Zeichensatzes (ASCII-00 bis ASCII-255) verwendet. Somit können die Zahlen der GRUND-VARIATION direkt auf die ASCII-Werte der Zeichen bezogen werden. Aus den Zahlen der GRUND-VARIATION erzeugt das Verfahren in jeder Runde in drei Schleifen (Permutationen) die CypherMatrix.
k = Alpha Initialisierung
FOR i = 1 TO 16
FOR j = 1 TO 16
Matrix$(1,i,j) = CHR$(Variation(k)) GRUND-VARIATION
INCR k 256 Elemente
IF k > 256 THEN k = 1
NEXT j
NEXT i
CypherSet$ = "" CypherMatrix in
FOR s = 1 TO 3 drei Schleifen
FOR i = 1 TO 16 (Permutation)
FOR j = 1 TO 16
a = i - j
IF a <= 0 THEN a = 16 + a
SELECT CASE s
CASE 1
Matrix$(2,a,j) = Matrix$(1,i,j)
CASE 2
Matrix$(3,a,j) = Matrix$(2,i,j)
CASE 3
Char$ = Matrix$(3,i,j)
CypherSet$ = CypherSet$+Char$ SERIES01.RND
END SELECT
NEXT j
NEXT i
NEXT s
Mit den drei Schleifen wird eine vollständige Permutation aller Zeichen erreicht.
Cypher-Matrix (16x16) aus der GRUND-VARIATION
(256 Elemente)
1 FD 64 F9 DA 57 EA 9C 79 5D A7 D0 F8 4A 8D 7E 84 16
17 A0 02 30 0A 9F 91 42 BD C7 17 1A A6 26 46 68 49 32
33 67 09 DC DE 11 1C AB E2 CA 63 D4 AD 22 CB 58 29 48
49 41 1F 37 E9 24 48 76 60 33 F0 D6 6D 5C CC 08 4D 64
65 AA 2F 9A 36 90 6A BC 39 FC AE A3 B0 4F C9 E8 A2 80
81 3A 0D 93 8E 01 44 70 A8 A4 EE 69 0B 16 95 59 2E 96
97 D8 43 D2 B9 04 55 8A 56 7C A1 AF FB E3 BE 98 F6 112
113 2C DD 88 15 F5 B6 51 0F DB 61 7D 34 14 3C 62 6E 128
129 B1 CD BB F1 0C C6 F7 CF 73 1E 2B 71 82 2D 50 B2 144
145 F3 80 3F 18 4E FE 87 5E 5F AC F4 C3 40 6C 9D 27 160
161 EC E7 C4 07 B4 B8 ED 72 F2 7A 35 EF 66 97 19 53 176
177 7F 10 3B 45 C0 3D D9 92 6B FA C2 FF 9B 5B 2A E6 192
193 28 8F 74 4B D3 B5 DF 96 65 6F 85 89 E0 BA 25 E1 208
209 E5 13 31 B3 52 CE 12 38 C8 21 47 54 EB 05 C1 3E 224
225 8C D5 03 32 A5 8B 1D C5 BF 77 83 78 75 D7 0E E4 240
241 D1 81 06 00 B7 99 94 7B 4C 9E 86 A9 5A 23 1B 20 256
Die blauen Elemente entsprechen dem ab Parameter Alpha (Position 91+3=94)
herausgezogenen Chiffretext-Alphabet.
Für jedes Zeichen besteht die gleiche Wahrscheinlichkeit an eine andere Stelle der Matrix umgesetzt zu werden. Infolge Ableitung des Matrix-Schlüssels aus der vorhergehenden Matrix und Verwendung als Eingabe für den nächsten Durchlauf wirken sich alle Permutationen direkt auf die jeweils folgende Runde aus, und damit auch auf das gesamte Verfahren. Da für jedes Zeichen in den Permutationen die gleiche Wahrscheinlichkeit besteht, dass es "weitergereicht" wird, kommen hier starke Zufallsmomente (Randomeffekte) ins Spiel. Diese Eigenschaft wird für die Erzeugung unbegrenzter Zeichen-Folgen (DNG) genutzt, die dann in Bits- oder Bytes umgeformt werden können. Im Vergleich mit Verschlüsselungen sind hier Blockschlüssel und XOR-Techniken nicht erforderlich. Alle Elemente der CypherMatrix werden zusammengefasst im String CypherSet$ und als Byte-Folge seriell in die unbegrenzte Datei SERIES01.RND geschrieben.
In jeder Runde entsteht eine neue CypherMatrix als Ergebnis der doppelten Einweg-Funktionen.
Eine Wiederholung derselben Struktur tritt nach den Grundsätzen der Wahrscheinlichkeit erst in 256!
(Fakultät) = 8E+506 Fällen auf. Das dürfte für Random-Eigenschaften ausreichend sein.
In jeder Runde bewirken die Steuerungsparameter (Alpha, Beta, Gamma, Delta und Theta) in Verbindung mit weiteren Schlüssel-Parameter ab unterschiedlichen Offsets der CypherMatrix die Entnahme der für bestimmte Verfahrensschritte erforderlichen Teilmengen von Zeichen. Für Hash-Berechnungen ist außer Variante nur Gamma erforderlich, für Verschlüsselungen müssen zusätzlich auch Alpha und Beta berücksichtigt werden. Delta und Theta kommen nur für Bytefolgen infrage.
Die Bestimmung der Teilmenge "Alphabet" (128 Zeichen) geschieht ab dem Steuerungsfaktor Alpha (Steuerungszeichen und ausgeblendete Zeichen werden übersprungen) mit folgendem Verlauf:
Ableitung des Chiffretext-Alphabets (128 Zeichen)
n = Alpha - 1
FOR i = 1 TO 128
INCR n
IF n > 256 THEN n = 1
Zeichen$ = MID$(CypherSet$,n,1) [Cypher-string]
SELECT CASE ASC(Zeichen$)
CASE <32 [ohne Steuerungszeichen]
DECR i
CASE 34,44,219,xxx [Ausblenden von Zeichen]
DECR i
CASE ELSE [Geheim-Zeichen Array]
ChiffreArray$(i) = Zeichen$
END SELECT
NEXT i
Bei der Entnahme der Zeichen werden bestimmte Zeichen (Steuerungszeichen ASCII-00 bis ASCII-31,
ASCII-34,44 u.a) ausgeblendet, weil sie in bestimmten Situationen noch ihren eigentlichen
Aufgaben nachgehen (z.B. ASCII-26) und den Ablauf durcheinander bringen.
Geheim-Zeichen Alphabet (Array 128 Zeichen)
Offset: Alpha = 91
Index 1 - 16: Y . C U V |
Index 17 - 32: Q a } 4 < b n
Index 33 - 48: s + q - P ? N ^ _
Index 49 - 64: @ l ' r z
Index 65 - 80: 5 f S ; E = k
Index 81 - 96: [ * ( t K e o
Index 97 - 112: % ß 1 R 8 ! G T >
Index 113 - 128: 2 w x u ü
Geheim-Zeichen-Alphabet: hexadezimal
95 59 2E D8 43 D2 B9 55 8A 56 7C A1 AF FB E3 BE
98 F6 88 F5 B6 51 61 7D 34 3C 62 6E CD BB F1 C6
F7 CF 73 2B 71 82 2D 50 F3 80 3F 4E FE 87 5E 5F
AC F4 C3 40 6C 9D 27 EC E7 C4 B4 B8 ED 72 F2 7A
35 EF 66 97 53 7F 3B 45 C0 3D D9 92 6B FA C2 9B
5B 2A E6 28 8F 74 4B D3 B5 96 65 6F 85 89 E0 BA
25 E1 E5 31 B3 52 CE 38 C8 21 47 54 EB C1 3E 8C
D5 32 A5 8B C5 BF 77 83 78 75 D7 E4 D1 81 B7 99
Das Geheim-Zeichen-Alphabet als Chiffre-Alphabet wird in allen Verschlüsselungen mit
CypherMatrix als Generator erzeugt.
In der ersten Runde entnimmt das Verfahren der CypherMatrix ab Parameter Gamma die folgende Zeichensequenz:
Matrix-Schlüssel (ab Offset: Gamma = 150 --> 42 Byte)
^_@l'rz5fS;E=ْk[*
FE 87 5E 5F AC F4 C3 40 6C 9D 27 EC E7 C4 07 B4 B8 ED 72 F2 7A
35 EF 66 97 19 53 7F 10 3B 45 C0 3D D9 92 6B FA C2 FF 9B 5B 2A
Der Matrix-Schlüssel wird auf den Eingang des Verfahrens zurückgeführt (loop) und
dient zur Initialisierung der nächsten Runde. Die Folge der Matrix-Schlüssel steuert den
identischen Ablauf des gesamten Verfahrens beim Sender und beim Empfänger.
Für XOR-Verknüpfungen mit wahlweise Klartext-Blocks von 7 bis 70 Bytes (insbesondere 63 Zeichen) bestimmt die Variable Beta die Position, ab der eine Sequenz in der gewählten Blocklänge (z.B. 63 zeichen) als Block-Schlüssel aus der CypherMatrix entnommen wird.
In der ersten Verfahrensrunde generiert die Funktion den folgenden Block-Schlüssel:
Block-Schlüssel (ab Offset: Beta = 66 --> 63 Byte)
/6j9O:.Dpi Y.CҹUV|㾘݈Qa}4.bn
2F 9A 36 90 6A BC 39 FC AE A3 B0 4F C9 E8 A2 3A 2E 93 8E 01 44
70 A8 A4 EE 69 0B 16 95 59 2E D8 43 D2 B9 04 55 8A 56 7C A1 AF
FB E3 BE 98 F6 DD 88 15 F5 B6 51 0F DB 61 7D 34 14 3C 62 6E B1
Die Länge der Klartext-Blöcke - und damit auch der Block-Schlüssel - kann
für jede Anwendung manuell mit 7 bis 70 Bytes (Vielfaches von 7), insbesondere 63 Bytes gewählt werden.
Block-Schlüssel sind nur in Verschlüsselungen mit XOR-Verknüpfungen erforderlich.
Die Start-Sequenz als Generalschlüssel steuert das gesamte Verfahren. Um jedoch zusätzliche Anwendungen mit dem Daten Generator zu verbinden, sind weitere Schlüssel-Parameter notwendig. Das folgende Bildschirmfoto zeigt die zur Verfügung stehenden Parameter:
Fü:r krypographische Anwendungen werden folgende Schlüssel-Parameter verwendet:
Länge des >Matrix-Schlüssels< : 36-64 Bytes
Länge der >Hash-Sequenz< : 32-96 Bytes
Länge des Block-Schlüssels : 35-96 Bytes
Zahlensystem zur Datenausgabe : 36-82 Grundziffern
Zahlensystem für Expansionsfunktion : 35-96 Grundziffern
individueller Anwender-Code : 1-99 Zahl
Die vom jeweiligen Programm vorbelegten Schlüssel-Parameter werden in der letzten Spalte
des Bildschirmfotos gezeigt. Bei den folgenden Erläuterungen der einzelnen Anwendungen sind die
notwendigen Parameter aufgeführt.
D. Anwendungen auf Basis des Verfahrens
Das CypherMatrix Verfahren bearbeitet fast ausschließlich Bytes im Gegensatz zu den heute sonst üblichen Verfahren mit Bit-Manipulationen. Zur Lösung kryptographischer Aufgaben sind insbesondere Anwendungen entwickelt zur:
Generierung von unbegrenzten dynamischen Zeichen-Folgen,
dynamischen Berechnung von seriellen und finalen Hash-Werten,
einfachen digitalen Signatur und natürlich
alle Arten von Verschlüsselungen mit
XOR-Verknüpfung, Bit-Konversion und zahlreichen weiteren
Operationen.
Der CypherMatrix Generator ist in jeder Anwendung der Kern des Verfahrens.
Die wichtigsten Prozeduren werden im Folgenden beschrieben.
1. Dynamic Number Generator (DNG)
Die Eigenschaft des Verfahrens, mit der jeweiligen CypherMatrix unbegrenzte Zeichenfolgen zu erzeugen, kann als dynamischer Zahlen Generator (DNG) verwendet werden. Es lassen sich periodische Zahlenfolgen und beliebig lange Bit- und Byte-Folgen generieren. Als Steuerungsparameter werden lediglich Variante, Gamma, Delta und Theta eingesetzt. Alpha und Beta sind nicht erforderlich. Als Schlüssel-Paraameter stehen zur Verfügung:
Länge des >Matrix-Schlüssels< : 36-64 Bytes
Zahlensystem für Expansionsfunktion : 35-96 Grundziffern
individueller Anwender-Code : 1-99 Zahl
a) Unbegrenzte Bit- und Byte-Folgen
Die vom Verfahren generiereten Zeichenfolgen (Byte stream) können wahlweise in 16-bit, 32-bit, 64-bit oder andere Bitfolgen beliebiger Länge umgeformt werden.
Die Erzeugung der Zeichenfolgen wird durch drei Betriebsarten gesteuert:
1. Für die jeweilige Permutation wird die laufende GRUND-VARIATION
verwendet (Continuous) oder
2. die MODULO-Rechnung zur Generierung der GRUND-VARIATION wird durch
dynamische Parameter (Theta) variiert, die in jeder Runde neu
erzeugt werden (Alternating).
3. Als dritter Modus werden unbegrenzte Zahlenfolgen generiert (DNG).
Die GRUND-VARIATION (k) leitet sich im Kontraktionsprozess (Abschnitt: C,2,c)
aus der Hash-Funktions-Reihe wie folgt ab:
FOR k=1 TO 256
Zahl = MID$(Reihe, k, 3) dreistellige Zahl Basis 86
CALL SystemNachDez (86, Zahl, Dezimal) Rückumwandlung
Element = (Dezimal MOD 256) Begrenzung auf 0 bis 255
Variation(k)=Element
IF k>1 THEN
n = 0
DO
INCR n
IF Variation(n) = Element THEN
INCR Element
Variation(k) = Element
n = 0
END IF
LOOP UNTIL n = k-1
END IF
Index = Variation(k) - Theta
IF Index<0 THEN Index = 256 + Index
Variation(k) = Index
NEXT k
Der Parameter Theta wird vom Verfahren mit (Hk MOD 32)+1 errechnet.
Alle Elemente der jeweiligen CypherMatrix von 256 Bytes werden in der Reihenfolge ihrer Verteilung in jeder Runde zeilenweise in eine Datei geschrieben (SERIESxx.RND). Die Länge der Folge hängt von der vorzugebenden Anzahl der Runden ab. Als "random number series" können sie dann für vielseitige kryptographische Aufgaben verwendet werden (beispielsweise als Schlüsseldatei für "one-time-pad" und "Multi-time-pad" Abläufe).
Das Programm Generate.exe zeigt mit der "Start-Sequenz"
in 20.000 Runden die folgenden Ergebnisse, gespeichert in der Datei SERIES01.RND:
Characters in the file SERIES01.RND File contains in total 5120000 characters, of these are 256 different characters; on the average 20000 positions per character yl9=v+rܨ%X~O[5 \ғ TV?jMsf0 F)Die Testprogramme FIPS PUB 140-1 vom U.S.NIST zeigen folgende Ergebnisse:"e|·, ƀ 20000 20000 20000 x 20000 y 20000 20000 ->13 20000 20000 20000 20000 20000 20000 l 20000 20000 20000 $ 20000 20000 20000 20000 20000 20000 20000 P 20000 20000 20000 s 20000 { 20000 ' 20000 9 20000 20000 q 20000 20000 20000 20000 K 20000 . 20000 20000 20000 20000 20000 20000 20000 20000 20000 20000 f 20000 ] 20000 3 20000 20000 0 20000 20000 20000 20000 20000 20000 S 20000 = 20000 20000 ->0 20000 b 20000 20000 F 20000 20000 20000 20000 20000 D 20000 20000 20000 ) 20000 8 20000 20000 20000 < 20000 n 20000 20000 >255 20000 20000 20000 20000 v 20000 p 20000 6 20000 20000 + 20000 A 20000 20000 20000 r 20000 ->32 20000 R 20000 * 20000 20000 I 20000 20000 W 20000 20000 20000 c 20000 20000 20000 20000 L 20000 B 20000 % 20000 20000 u 20000 2 20000 20000 20000 4 20000 20000 20000 } 20000 ` 20000 20000 X 20000 20000 20000 7 20000 ~ 20000 G 20000 / 20000 20000 20000 & 20000 H 20000 20000 20000 @ 20000 20000 20000 O 20000 20000 20000 20000 20000 20000 20000 20000 20000 20000 20000 ^ 20000 20000 20000 20000 J 20000 [ 20000 20000 20000 ->9 20000 20000 1 20000 z 20000 20000 5 20000 20000 a 20000 - 20000 20000 20000 . 20000 20000 ->26 20000 20000 h 20000 ! 20000 20000 20000 20000 ( 20000 20000 : 20000 20000 20000 20000 20000 N 20000 20000 \ 20000 _ 20000 Z 20000 20000 20000 20000 20000 20000 20000 U 20000 20000 > 20000 20000 20000 E 20000 20000 20000 ; 20000 i 20000 " 20000 20000 20000 20000 e 20000 20000 o 20000 20000 | 20000 20000 Q 20000 k 20000 20000 20000 # 20000 20000 20000 20000 20000 20000 20000 20000 Y 20000 20000 20000 20000 20000 g 20000 20000 20000 m 20000 t 20000 20000 T 20000 20000 ->10 20000 , 20000 V 20000 w 20000 20000 20000 ? 20000 20000 20000 20000 20000 20000 C 20000 20000 j 20000 20000 d 20000 20000 M 20000 20000 20000 20000 In total: 5120000 characters average value: 20000 standard deviation: 0 random factor [1.0]: 1 optimal result: factor < 2.0 -----------------------------------------------------------------------
Monobit Test
Zeros = 9987 and Ones = 10013
9.654 < 10013 < 10.346
The Test is passed
Runs Test
2478: "0" length 1 2506: "1" length 1
1270: "0" length 2 1236: "1" length 2
624: "0" length 3 620: "1" length 3
318: "0" length 4 336: "1" length 4
153: "0" length 5 150: "1" length 5
153: "0" length 6 149: "1" length 6
Das bekannte Testprogramm "ENT.EXE"
(verfügbar auf Anforderung) zeitigt auf Byte-Ebene folgendes Ergebnis:
Entropy = 8.000000 bits per byte Optimum compression would reduce the size of this 5120000 byte file by 0 percent Chi square distribution for 5120000 samples is 0.00, and randomly would exeed this value 99.99 percent of the times Arithmetic mean value of data bytes is 127.5000 (127.5 = random) Monte Carlo value for Pi is 3.138019976 (error 0.11 percent) Serial correlation coefficient is -0.001560 (totally uncorrelated = 0.0).
Diese Tests lassen erkennen, dass offensichtlich die Erfordernisse für einen Zufalls-Generator weitgehend erfüllt sind. Bei Änderungen der Start-Sequenz auch nur um ein Bit gibt es keine übereinstimmenden Zeichen mehr an gleichen Positionen der beiden generierten Dateien. Wird zum Beispiel in der obigen Start-Sequenz das letzte Bit am Ende von "1" auf "0" gesetzt, entstehen völlig unterschiedliche Ergebnisse:
Auf der Fischbachalm gibt es keine Heringe
Auf der Fischbachalm gibt es keine Heringd
e = 0110 0101
d = 0110 0100
Die mit den beiden Start-Sequenzen erzeugten Random-Dateien unterscheiden sich durch folgende Hash-Werte:
SERIES01.RND Basis 62: qqLOOcAaNV
Basis 16: 9ED75E11E63A6D1
Basis 10: 715357525559715537
SERIES02.RND Basis 62: qo27CBwr32
Basis 16: 9EBAAFA41827AB0
Basis 10: 714852957685971632
Sie können sich die beiden Random-Folgen als
ZIP Datei (10,24 MB): RNDFILES.ZIP auf Ihren Rechner holen und testen.
Das zugehörige Programm Generate.exe steht ebenfalls zum Herunterladen
zur Verfügung. Ihre System-Dateien werden dadurch nicht berührt.
Wird der Kontraktionsprozess anstatt mit MODULO 256 (Verdichtung zur Grund-Variation) anderweitig mit MODULO 8 (alternativ mit MODULO 16, 32, 64 oder andere) vorgenommen, lassen sich beliebige Zahlen-Folgen erzeugen, die für verschiedene kryptographische Zwecke verwendet werden können, wie beispielsweise für die Operationen "Bit-Exchange BE und Byte-Transposition BT als Kombinationen in Verschlüsselungen.
Die Basiszahlen zur Anwendung der MODULO-Rechnung können sowohl aus der CypherMatrix als auch aus den Elementen der GRUND-VARIATION abgeleitet werden. Der Beginn wird vom Parameter Delta geliefert:
Für die Basis einer 24-Bit-Folge, abgeleitet aus Delta = 31, ergeben sich folgende Reihen:
10 16 1 9 13 5 11 7 24 12 22 23 14 15 17 4 18 20 6 19 8 21 2 3
3 11 16 20 21 23 9 12 13 10 14 15 17 18 1 4 19 22 2 24 5 6 7 8
11 19 20 16 17 8 24 9 13 3 21 7 14 4 1 5 2 6 10 12 15 18 22 23
18 2 9 10 3 8 11 4 12 13 17 19 14 5 15 6 16 21 20 22 23 24 1 7
8 13 10 3 5 9 6 14 24 12 4 18 7 11 17 15 16 19 20 2 21 1 22 23
10 18 2 8 3 16 9 24 14 1 4 11 5 15 6 12 13 17 19 20 21 22 7 23
4 1 23 21 13 10 2 5 24 3 6 7 15 8 16 9 11 17 18 12 19 22 14 20
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mit der gleichen Technik können auch Basisfolgen für 16-, 32-, 64-bit oder andere Bit-Folgen
(Zahlenfolgen) generiert werden. Zum Beispiel: Herkömmliche S-Boxen als dynamische Folge
von 64 Bits oder Lotto-Zahlen (6 aus 49 + Zusatzzahl).
Sie können sich das Programm LottoTip.exe
auf Ihren Rechner holen und einmal damit spielen. Ihre Systemdateien werden dadurch nicht berührt.
Als weitere Anwendung bietet sich eine dynamische Hash-Funktion an zur eindeutigen Kennzeichnung digitaler Informationen. Dabei werden digitale Folgen (Dateien) in Textblöcke unterteilt, die dann als Eingangs-Sequenzen nacheinander positionsgewichted, mit der Hashkonstanten Ck multipliziert, zur Hash-Funktions-Reihe expandiert und wieder zur GRUND-VARIATION verdichtet einer dreifachen Permutation unterworfen werden (Abschnitt C,2,a-d). Das Ergebnis - die letzte CypherMatrix mit 256 Elementen - stellt den Hashwert (H) dar. Ein gleicher Hashwert kann erst in 256! (Fakultät) = 8E+506 Fällen auftreten. Wo soll da noch Platz für Kollisionen sein?
Verglichen mit aktuellen Hash-Funktionen hat das Verfahren einige Vorteile:
1. Die Einschaltung einer Kompression ist nicht erforderlich,
2. Nur Bytes und Mathematik werden benutzt, keine Bit-Manipulation,
3. Mit den Ergebnissen der Funktion kann gerechnet werden (z.B. Addition,
Subtraktion, Multiplikation, Division und Modulo-Rechnung) und
4. die Ergebnisse sind beachtlich kürzer als 128 Bit bzw. 160 Bit
(SHA, MD5, RIPE-MD).
Auf die Identifikationsdaten des Autors angewendet (113 Byte) ergeben sich
folgende Ergebnisse:
CypherMatrix Hash Basis 62: dnpjkSi7l
Basis 16: 1EE033B3567631
Basis 10: 8 690 761 958 061 627
SHA 1:
47 19 58 FF 6D 10 F5 CD 85 A3 0F 56 61 E9 E2 BE 0C 77 82 C4
MD5:
D9 B3 04 D2 E1 14 95 20 47 89 69 C1 8B DA FE 50
In einem RFID-Chip gespeichert kann der Hashwert mobil ausgelesen und abgeglichen werden.(in der letzten Position wird die Ziffer 9 dutch 8 ersetzt) 9 = 111 001
8 = 111 000
dann zeigen sich folgende Ergebnisse:
CypherMatrix Hash Basis 62: gLjlviYBm
Basis 16: 20D9ED1E651012
Basis 10: 9 246 811 695 157 266
SHA 1:
95 99 E1 4E 95 DA D9 DD E9 BA F6 92 BB 5F BC 99 29 49 CE 3E
MD5:
AB DA 29 40 D2 63 F8 D0 04 F0 82 42 14 04 06 AE
Wenn der CM-Hashwert als Fingerprint gesehen werden kann, dann sind SHA und MD5
ein Tatzelwurm!Bei SHA1 sind es 2^160 = 1,5E+48 und bei MD5 2^128 = 3,4E+38 Werte.
Grundsätzlich sind zwei Techniken möglich:
a) Serieller Abgriff partieller Hashwerte aus der CypherMatrix in jeder
Runde und Summierung zum Hashwert (serial mode: CMHash.exe) und
b) finaler Abgriff des Hashwertes aus der letzten CypherMatrix nach
Durchlaufen aller vorherigen Runden (final mode: CMXHash.exe).
Als Schlüssel-Parameter werden benötigt:
Länge der >Hash-Sequenz< : 32-96 Bytes
Zahlensystem zur Datenausgabe : 36-82 Grundziffern
Zahlensystem für Expansionsfunktion : 35-96 Grundziffern
individueller Anwender-Code : 1-99 Zahl
An die Stelle des >Matrix-Schlüssels< tritt die >Hash-Sequenz<.
Die Zusammenhänge veranschaulichen folgende Skizzen:
Entwicklung und Arbeitsweise der "CypherMatrix Hash Funktion" werden ausführlich in der folgenden Pdf-Datei dargelegt:
3. Erweiterte digitale Signatur
Wird die Hash-Funktion, sowohl auf eine zu signierende Nachricht als auch auf die Identifikations-Daten (ID) des Signierenden (einschließlich Bild und Unterschrift) angewendet, ergibt sich eine erweiterte digitale Signatur". Als Schlüssel-Parameter werden eingegeben:
Länge der >Hash-Sequenz< : 32-96 Bytes
Zahlensystem zur Datenausgabe : 36-82 Grundziffern
Zahlensystem für Expansionsfunktion : 35-96 Grundziffern
individueller Anwender-Code : 1-99 Zahl
Die >Hash-Sequenz< tritt an die Stelle des >Matrix-Schlüssels<.
Die Zusammenhänge zeigt folgendes Bild:
(Hinweis: Name und Daten sind frei erfunden)
Name, Wohnort: Hans-Georg Sommer, München
Geburtstag, -ort: 14.07.1954/Michaelisdon/Holstein
pers. Passphrase: Die weiße Elster fließt in das schwarze Meer
Ausweis-Nummer: 1234567-abc-890
Hash-Wert pers.Daten (Basis 62): XtvI0lCoV
Pass-Photo (MyPhoto.jpg): + dw8oNYQY3
Unterschrift (MySign.jpg): + YPHYJOpaf
------------
ID-Daten (Basis 62): = 1kFlehiSxD
Aus Sicherheitsgründen wird eine Ein-Weg-Hashfunktion eingefügt,
die für den Anwender einen einmaligen Referenz-Code generiert:
ID-Daten Hash Referenz-Code
Basis 62 1kFlehiSxD ---> 10JO818Dyf
Basis 16 53F90E37992B57 ---> 30560289480B35
dezimal 23636262524627799 ---> 13605367775234869
Wenn der Referenz-Code des Anwenders zum Hash-Wert einer Datei addiert wird, entsteht eine "einfache Signatur" [#18] des Dokuments (hier als >teleCode< bezeichnet).
Basis 62 Basis 16 dezimal
Referenz-Code Absender 10JO818Dyf 30560289480B35 13605367775234869
+ Datei HESSE.TXT + YKUfRFfCG + 1AA15578120F34 + 7495737853218612
+ Data-check *) + 3fe0p + 33BDABB + 54254267
------------- ---------------- -------------------
teleCode 1YdsnW3XBk 4AF7580495F524 21101105682707748
*) Um zu vermeiden, dass der Hash-Wert der ID-Daten des Absenders errechnet werden kann, wird in der Addition der Hash-Werte ein Data-Check zwischengeschaltet. Sein Wert ergibt sich aus der Datei, wird aber allen Beteiligten nicht bekannt.
Der >teleCode< als erweiterte digitale Signatur stellt einen eindeutigen Ausdruck für
den Inhalt der Nachricht und den Absender in kompakter Form dar. Wird der
>teleCode< zusammen mit der Datei übermittelt, kann jeder Empfänger zuerst
mit der Hash-Funktion den Hash-Wert der Datei ermitteln und dann aus der
Differenz zum erhaltenen >teleCode< den Referenz-Code des Absenders errechnen.
Werden die Daten vom Absender außerdem in einer Internet-Datenbank ("Signatur-Portal")
gespeichert (verschlüsselt), kann der Empfänger durch eine Rückfrage in der
Datenbank sowohl die Integrität der Nachricht als auch die Identität des Absenders
überprüfen. Zusätzlich kann der Empfänger auch noch das Pass-Photo und die Unterschrift
des Senders auf seinen Rechner holen und selbst verifizieren. Einzelheiten finden Sie im Artikel:
Die eigentliche Verschlüsselung - der Weg vom Klartext-Zeichen zum Chiffretext-Zeichen und wieder zurück - ist bis jetzt überhaupt noch nicht ins Spiel gekommen. Alle bisher erläuterten Vorgänge dienen ausschließlich dem Aufbau und parallelen Ablauf des CypherMatrix Generators (kryptographischer Mechanismus) beim Sender und beim Empfänger. Die Verschlüsselung als symetrisches Verfahren wird von zusätzlichen eigenen Codierfunktionen gesteuert (insbesondere: Substitutionen und Transpositionen). Für jedes Programm sind folgende Schlüssel-Parameter erforderlich:
Länge des >Matrix-Schlüssels< : 36-64 Bytes
Länge des Block-Schlüssels : 35-96 Bytes
Zahlensystem für Expansionsfunktion : 35-96 Grundziffern
individueller Anwender-Code : 1-99 Zahl
Das CypherMatrix Verfahren bewirkt die Verschlüsselung mit der Kombination von geeigneten Operationen: XOR-Verknüpfung, Substitution "dyn24", Bit-Konversion und Bit-Exchange sowie weitere im Einzelnen noch darzustellende Operationen:
Die XOR-Verknüpfung ist eine Standardoperation. Da bei einfachem XOR noch kein wirklicher Schutz gegeben ist [#6], verwendet das Verfahren als weiteren Verschlüsselungsschritt eine Substitution "dyn24". Weitere Lösungen sind insbesondere die "Bit-Konversion BC: C1,2,3,4" und "Bit-Exchange BE" (Bezeichnungen vom Autor).
Mit den genannten Operationen lassen sich unter anderem folgende Kombinationen gestalten:
Weitere Kombinationen sind möglich, insbesondere im drei- und vierfachen Bereich und mit weiteren noch zu suchenden Operationen. Der Forschung ist kein Ende gesetzt.
Als Klartext P wird grundsätzlich jedes Byte (8 Bits) erfasst, d.h. insbesondere alle 256 ASCII-Zeichen, aber auch Pixel und alle anderen binär gespeicherten Daten. Ein eingeschränkter Umfang, wie in den Verfahren "R6Cipher" und "R7Cipher" (vgl. Abschnitt B), bleibt unberücksichtigt. Für jede Kombination entsteht ein eigenes mit anderen nicht vergleichbares Chiffrat. Die Kombinationen mit der Bit-Konversion (C2) sind nicht brechbar, da die Längenkongruenz fehlt. Kein Chiffre-Zeichen kann einem bestimmten Klartext-Zeichen zugeordnet werden. Alle anderen Kombinationen sind, wie aktuelle Verfahren auch, den heute bekannten Angriffen ausgesetzt.
Für eine sichere Verschlüsselung am besten geeignet sind die zweifachen Kombinationen: P - X - C2 (CYPHER22), P - Y - C2 (CYPHER24) und die dreifachen Kombinationen P - X - Y - C2 (CYPHER31) und P - Y - X - C2 (CYPHER33). Die Verschlüsselung - beispielsweise CYPHER22 - vollzieht sich in drei Funktionen:
1. Partielles dynamisches "One-time-pad":
Klartext --> Schlüssel --> XOR-Verknüpfung,
2. Bit-Konversion:
8-bit XOR Verknüpfung --> 7-bit Indexwerte (0...127) und
3. Bestimmung des Chiffretextes:
7-bit Indexwerte --> Chiffre-Array (0...127) --> Chiffretext.
Das folgende Schema zeigt die Zusammenhänge:
In jeder Runde sind der Klartext und der aus der CypherMatrix entnommene Schlüssel
immer gleich lang (hier gewählt: 63 Bytes). Klartext und Schlüssel werden miteinander
XOR-verknüpft. Im Prinzip entsteht so ein partielles dynamisches "One-time-pad"
jeweils für einen Zyklus. Der Schlüssel wird auch nicht wiederholt, da in jeder Runde ein anderer
Schlüssel erzeugt wird.
Die folgende Verschlüsselung wurde mit dem Programm CypherXT.exe durchgeführt. Für das begleitende Beispiel wählen wir Worte von Hermann Hesse (Datei: HESSE.TXT"):
Als Siddhartha den Hain verließ, in welchem der Buddha, der Vollendete, zurückblieb, in welchem Govinda zurückblieb, da fühlte er, dass in diesem Hain auch sein bisheriges Leben hinter ihm zurückblieb und sich von ihm trennte.
Klartext (63 Bytes)
Als Siddharta den Hain verließ, in welchem der Buddha, der Voll ...
41 6C 73 20 53 69 64 64 68 61 72 74 61 20 64 65 6E 20 48 61 69
6E 20 76 65 72 6C 69 65 E1 2C 20 69 6E 20 77 65 6C 63 68 65 6D
20 64 65 72 20 42 75 64 64 68 61 2C 20 64 65 72 20 56 6F 6C 6C
Block-Schlüssel (63 Bytes)
0HWF+/7ڍ.~.&..jNgJb.̀MCw1u#.
FD 30 8C B4 48 57 EF F7 46 2B 2F C6 37 E0 DA 8D C4 F4 F2 ED F9
0F 7E 1E AB 9E 97 A1 82 26 18 05 6A FF B3 4E 98 67 D0 4A 62 BF
DC 13 E5 B2 E4 AE CD 80 4D 43 C3 77 B1 B0 31 7F 75 23 F3 01 DF
XOR-Verknüpfung (63 Bytes)
\.>.J]VԺa^h4%.9.".w)+[T.Uum
BC 5C FF 94 1B 3E 8B 93 2E 4A 5D B2 56 C0 BE E8 AA D4 BA 8C 90
61 5E 68 CE EC FB C8 E7 C7 34 25 03 91 93 39 FD 0B B3 22 07 D2
FC 77 80 C0 C4 EC B8 E4 29 2B A2 5B 91 D4 54 0D 55 75 9C 6D B3
Die XOR-Operation allein (Cypher11) ist nicht sicher genug, sie muss mit weiteren
Verschlüsselungsschritten kombiniert werden.
Als weiterer alternativer Verschlüsselungsschritt kann der XOR-Verknüpfung die Substitution "dyn24" (Bezeichnung vom Autor) nachgeordnet (CYPHER21) oder vorgeschaltet werden (CYPHER23). Im Folgenden wird die Substitution anstelle der XOR-Verknüpfung eingesetzt (CYPHER12).
Aus der GRUND-VARIATION mit 16 Elementen generiert das Verfahren durch zyklische Permutationen zwei vierdimensionale Matrizen (2x2x2x2 Zeichen): Matrix A und Matrix B. In der jeweiligen Matrix sind alle einstelligen hexadezimalen Ziffern (0 - F) gut durchmischt gespeichert. Vor jedem Zyklus von z.B. 63 Klartextzeichen werden die Zeichen permutiert und Matrix A und Matrix B neu gebildet.
GRUND-VARIATION (16 Elemente)
Matrix A: 0 2 12 15 4 11 13 14 1 3 5 6 7 8 9 10
Matrix B: 10 0 12 1 5 4 15 6 14 7 3 8 9 11 2 13
Substitution >dyn24<
(2 Matrixen mit je 4 Dimensionen)
Matrix A
0 C 4 D 1 5 7 9
2 F B E 3 6 8 A
Matrix B
A C 5 F E 3 9 2
0 1 4 6 7 8 B D
Zur Substitution eines Klartextzeichens nimmt das Programm dessen 8-bit Sequenz
in hexadezimaler Notation (zweistellig: 00 bis FF), sucht die erste Stelle in der Matrix A,
die zweite Stelle in der Matrix B und verbindet die je vier gefundenen Indizes
(0000 bis 1111) zu einer achtstelligen Binärzahl. Diese Binärzahlen stellen
die Substitution des jeweiligen Klartextzeichens dar. Eine Substitution des Klartextes
Blue flamingos gestaltet sich wie folgt:
Klar- 1. Matrix 2. Matrix Binär- Subst-
text Hex Stelle A Stelle B zahl Hex zeichn
B 42 4 0100 2 1110 01001110 4E N
l 6C 6 1011 C 0010 10110010 B2
u 75 7 1100 5 1010 11001010 CA
e 65 6 1011 5 1010 10111010 BA
20 2 0001 0 0001 00010001 11 P
f 66 6 1011 6 0111 10110111 B7
l 6C 6 1011 C 0010 10110010 B2
a 61 6 1011 1 0011 10110011 B3
m 6D 6 1011 D 1111 10111111 BF
i 69 6 1011 9 1100 10111100 BC
n 6E 6 1011 E 1000 10111000 B8
g 67 6 1011 7 1001 10111001 B9
o 6F 6 1011 F 0110 10110110 B6
s 73 7 1100 3 1010 11001010 CA
Binärfolge: 01001110 10110010 11001010 10111010 00010001 10110111 10110010
10110011 10111111 10111100 10111000 10111001 10110110 11001010
Unter Verwendung des erweiterten ASCII-Zeichensatzes ergibt sich als Substitution die
Zeichenfolge: NʺP. Die binäre Zeichenfolge kann anschließend
mit dem jeweiligen Block-Schlüssel XOR-verknüpft (CYPHER23) oder einer Bit Konversion
unterworfen werden (CYPHER24). Mit dem Programm "Cypher24.exe"
können Sie die dynamische Substitution einmal selbst testen. Ihre Systemdateien werden nicht
berührt.
Hinweis: Da die Indizes (-1) einer vierdimensionalen Matrix im binären Zahlensystem vermutlich nicht immer gegenwärtig sind, werden sie noch einmal gezeigt:
Dim. 1 Dim. 2 Dim. 3 Dim. 4
0000 0010 0100 0110 1000 1010 1100 1110
0001 0011 0101 0111 1001 1011 1101 1111
Die "bit-conversion BC" ist datentechnisch eine Änderung der Anzahl der Bits in dem entsprechenden Zeichen (C1,2,3,4). Sie bietet die Möglichkeit, Klartext-Zeichen und Chiffretext-Zeichen funktional zu trennen. Die Folge der 8-bit Sequenzen aus der XOR-Verknüpfung teilt das Programm mit einer "Bit-Konversion" in eine Folge von 7-bit Sequenzen. Aus 63 8-bit Sequenzen werden 72 7-bit Sequenzen. Dabei bleiben die Anzahl der Bits und ihre Reihenfolge gleich. Kein Bit wird hinzugefügt und kein Bit weggelassen. Die dezimalen Werte der 7-bit Sequenzen sind Indexwerte für die Positionen der Zeichen im Chiffretext-Alphabet. Auf diese Weise entstehen aus 7 Klartextzeichen 8 Transfer-Zeichen. Die Zeichen werden zum Chiffretext verbunden und zum Empfänger geschickt. Lesen Sie die beiden folgenden PDF-Dateien.
Schematisch zeigt sich folgender Ablauf:
Am besten bekannt ist das Verfahren "Coding Base 64". Dort werden die 8-bit Sequenzen des Klartextes in eine Folge von 6-bit Sequenzen umgewandelt, deren dezimale Werte als Indizes für ein Chiffre-Alphabet von 64 Zeichen verwendet werden. Das Chiffre-Alphabet kann entweder statisch vorgegeben werden
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef [32]
ghijklmnopqrstuvwxyz0123456789+/ [64]
oder dynamisch in jeder Runde erneut permutiert werden:
UsdmVTi86AlrZg0tM/jeohq3wCXIpRcy [32]
abu+Dk2fWNOQ9GFvJHx47YnKSL5B1EzP [64]
Dieses Chiffre-Alphabet wurde im CypherMatrix Verfahren mit der persönlichen Passphrase "Regenbogenforellen"
(12 bis 24 Zeichen) permutiert. In Klartextabständen von z.B. 63 Bytes wird das Chiffre-Alphabet
immer wieder neu generiert. Verglichen mit dem Klartext verlängert sich der Chiffretext im
Verhältnis 6:8.
Im CypherMatrix Verfahren wird zur Durchführung der Bit Konversion das Chiffre-Alphabet mit
128 Zeichen festgelegt. Die Folgen der 8-bit Sequenzen aus den XOR-Verknüpfungen
(0...255) werden in Folgen von 7-bit Sequenzen aufgeteilt (0...127) und als Indizes (+1) für die im
Geheim-Zeichen-Array (1...128) gespeicherten Chiffretext-Zeichen verwendet. Die funktionale Verbindung zwischen Klartext und
Chiffretext wird auf diese Weise durchbrochen.
Der gewählte Klartext wird folgendermaßen weiter bearbeitet:
XOR-Verknüpfung vor der Bit-Konversion
\.>.J]VԺa^h4%.9.".w)+[T.Uum
BC 5C FF 94 1B 3E 8B 93 2E 4A 5D B2 56 C0 BE E8 AA D4 BA 8C 90
61 5E 68 CE EC FB C8 E7 C7 34 25 03 91 93 39 FD 0B B3 22 07 D2
FC 77 80 C0 C4 EC B8 E4 29 2B A2 5B 91 D4 54 0D 55 75 9C 6D B3
>Bit Conversion<
8-bit XOR-Sequenzen umgegliedert in 7-bit Sequenzen als "Index-Werte"
8-bit: 10111100010111001111111110010100000110110011111010001011 ....
7-bit: 10111100010111001111111110010100000110110011111010001011 ....
Hexadezimale 7-bit Werte nach der Bit-Konversion
5E 17 1F 79 20 6C 7D 0B 49 4B 49 25 6D 49 2D 40 5F 3A 15 2D 25
6A 19 10 30 57 4D 0C 77 33 77 48 73 71 66 42 28 0E 23 13 1C 7F
21 3B 19 08 0F 52 7E 1D 70 0C 06 13 59 38 72 0A 25 3A 12 6E 23
54 2A 03 2A 57 2C 71 5B 33
Dezimale Index-Werte (+1) für das Chiffretext-Array
095 024 032 122 033 109 126 012 074 076 074 038 110 074 046 065
096 059 022 046 038 107 026 017 049 088 078 013 120 052 120 073
116 114 103 067 041 015 036 020 029 128 034 060 026 009 016 083
127 030 113 013 007 020 090 057 115 011 038 059 019 111 036 085
043 004 043 088 045 114 092 052
Verschlüsselter Chiffretext
_G$Ԫ!TU]5T!rxl>hҸ8ca!]=6[{[8Dh
5F CA 47 CB 24 91 D4 AA F1 EA F1 21 BD F1 54 55 F0 5D 35 54 21
C0 72 78 A4 C7 6C 3E 89 68 89 D2 B8 38 3C 58 CF FC E6 FB 2D A3
70 B5 72 C1 BB 28 A6 94 84 3E D8 FB 63 FA AC 61 21 5D 3D F5 E6
36 5B 7B 5B C7 E3 38 44 68
Mit der Eingabe der Start Sequenz erzeugt der Empfänger einen identischen Aufbau und Ablauf
des gesamten Verfahrens. Dabei sucht das Verfahren die erhaltenen Zeichen im jeweiligen Array des
Chiffretext-Alphabets, stellt den Index des Zeichen fest [1...128] (index values),
wandelt den Index (-1) um in einen binären 7-bit Wert und verbindet die Werte zu einer 7-bit Folge.
Die Folge wird dann wieder in 8-bit Sequenzen aufgeteilt. Aus 72 7-bit Sequenzen
entstehen 63 8-bit Sequenzen (bit conversion). Die entstehende Folge entspricht der
beim Sender erzeugten XOR-Verknüpfung und kann mit Hilfe des identisch erzeugten Block-Schlüssels
in den ursprünglichen Klartext zurück verwandelt und gelesen werden.
Eine grundsätzliche Wirkung der "bit-conversion" wird in diesem Beispiel deutlich: die Länge des Textes erweitert sich, und zwar hier im Verhältnis 7:8. Aus ursprünglichen 7 Klartext-Zeichen werden 8 umgewandelte Chiffretext-Zeichen.
Als neueste Entwicklung des CypherMatrix Verfahrens können Sie sich das Programm
teleCypher.exe auf Ihren Rechner holen und alle Funktionen einmal
selbst testen.
Wenn Klartext-Alphabet mit 256 Zeichen und das Chiffretext-Alphabet ebenfalls mit 256 Zeichen denselben Umfang haben, aber nicht die gleiche Struktur, ist prima facies eine "bit-conversion" natürlich nicht möglich. Aber gleichwohl kann eine Struktur-Umwandlung (SC) vorgenommen werden (dynamische Transposition). Dabei wird in definierten Klartext-Abständen das Chiffretext-Alphabet dreifach permutiert und in einem Index-Array von 256 Zeichen gespeichert. Nach XOR-Verknüpfung des Klartext-Blocks mit gleich langem Block-Schlüssel werden die resultierenden Zeichen durch die mit gleichem Index gespeicherten Chiffretext-Zeichen ersetzt. Die folgende Skizze zeigt das Prinzip:
Da jedes Klartext-Zeichen durch ein Alphabet-Zeichen ersetzt wird, bleibt natürlich die Längenkongruenz erhalten. Insoweit besteht eine Abweichung gegenüber allen anderen CypherMatrix-Verschlüsselungen. Wenn Sie das spezielle Programm CypherSC.exe (entspricht Cypher71.exe) einmal testen möchten, können Sie es ohne Beeinflussung Ihrer System-Dateien auf Ihren Rechner holen.
Das Prinzip der Bit Konversion kann auch auf Umwandlungen von 8-bit-Sequenzen auf 9-bit-Sequenzen angewendet werden. Das Geheim-Zeichen-Array muss dann allerdings 2^9 = 512 Chiffretext-Zeichen enthalten. Am besten lässt sich das mit japanischen und chinesischen Schriftzeichen darstellen (die dem Autor allerdings nicht zur Verfügung stehen).
Jeweils 9 Bytes (72 Bits) - Klartext oder XOR-verknüpft - werden in 8 Index-Werte zu je 9 Bits umgruppiert. Die Chiffretext-Zeichen werden in jeder Runde nach gründlicher Permutation in einer dreidimensionalen Matrix (8x8x8 = 512 Zeichen) gespeichert. Ein Beispiel:
Klartext: "neue Welt"
9 Sequenzen mit 8-Bit:
110 101 117 101 32
0110111001100101011101010110010100100000
87 101 108 116
01010111011001010110110001110100
8 Sequenzen mit 9-Bit:
220(334) 405(625) 427(653) 82(122)
011011100110010101110101011001010010
10(12) 473(731) 182(266)116(164)
000001010111011001010110110001110100
Chiffre-Text: "frRzUouGK"
(Die Zeichen sind mit dem folgenden Programm generiert)
Der höchste 9-Bit-Wert ist: 111111111 = 512. Mit der Umwandlung in dezimale Zahlen können somit 512 Index-Werte erreicht werden. Werden einelementige Zeichen verwendet, verkürzt sich der Chiffretext im Verhältnis 9:8. Die Adressierung des Chiffretexts erfogt mit 512 Elementen im Zahlensystem zur Basis 8 (000 bis 777, in den obigen Index-Werten in grün gezeigt). Da normalerweise im ASCII-Zeichensatz keine 512 Elemente verfügbar sind, kann man am besten für ein Element je zwei Zeichen aus den Ziffern des Zahlensystems zur Basis 128 (00 bis =[16383]) in einem Alphabet-Array 8x8x8 verwenden. Das Verfahren hat jedoch einen Nachteil: die Länge der Chiffre-Datei verlängert sich um den Faktor 1,77 (natürlich wegen der doppelten Zeichenlänge).
Höherwertige Bit-Umwandlungen (10-Bit-Sequenzen und höher) sind datentechnisch ebenfalls möglich, aber es steigt auch der Bedarf an unterscheidbaren Chiffretextzeichen:
10-Bit-Sequenz: 2^10 = 1024 Zeichen
12-Bit-Sequenz: 2^12 = 4096 Zeichen
16-Bit-Sequenz: 2^16 = 65536 Zeichen
Um die Arbeitsweise eines Programms mit integrierter Konversion von 8-bit Sequenzen nach 9-bit Sequenzen einmal zu
testen, können Sie sich das Program CYPHER89.EXE
auf Ihren Rechner holen und alles einmal selbst ausprobieren. Ihre System-Dateien werden
dadurch nicht berührt.
Das Prinzip der Bit Konversion lässt sich auch auf andere Zahlensysteme übertragem, zum Beispiel
auf das Zahlensystem zur Basis 4. Die Operation
wandelt 4-stellige Basis-4 Zahlen in 3-stellige Zahlen gleicher Basis um. Mit den vierstelligen Zahlen 0000 bis 3333 werden alle ASCII-Indexwerte von 0 bis 255 erfasst. Die dreistelligen Zahlen 000 bis 333 decken den Bereich von 0 bis 63 ab. Damit kann ein variables Chiffre-Alphabet von 64 Zeichen angesprochen werden, das in jedem Zyklus von beispielsweise 15 Klartextzeichen jeweils neu mit ((Hk+Hp) MOD 255)+1) aus der aktuellen CypherMatrix herausgezogen wird.
Die Verschlüsselung wird mit drei Funktionen erreicht:
1. Klartext --> Basis4(4) --> Basis4(3)
2. Start-Sequenz --> Chiffre-Array(64)
3. Basis4(3) --> Chiffre-Array(64) --> Chiffretext
Die Zusammenhänge zeigt das Beispiel "Yellowstonepark":
Y e l l o w s t o n e p a r k ASCII dez: 89 101 108 108 111 119 115 116 111 110 101 112 97 114 107Basis 4 vierstellig
Basis 4 dreistellig
112112111230123012331
313130313101233123
212111300120113021223
Index Chiffre-Alphabet:
22 22 21 44 27 6 61 55 28 55 17 47 27 38 21 48 24 23 9 43
Chiffre-Text:
wƓ]4Y4wk"d
Zur sicheren Verschlüsselung kann die Operation mit anderen oben vorgestellten Verfahren und weiteren Möglichkeiten kombiniert werden.
Die Operation "bit-conversion" hat einen beachtlichen Nachteil: Bei der Umwandlung von 8-bit Sequenzen in 7-bit Sequenzen (Chiffre-Alphabet 128) verlängert sich der Chiffretext gegenüber dem Klartext im Verhältnis 7 zu 8. In der Praxis wird jedoch oft verlangt, den Chiffretext wieder im Speicherbereich des bisherigen Klartextes abzulegen. Dafür ist natürlich eine gleiche Länge der Texte zwingend erforderlich. Ein zusäzlicher Speicherplatz wird nicht benötigt.
Dieser Nachteil lässt sich auf einfache Weise vermeiden: Der "bit-conversion" wird eine Bit-Regression (Bezeichnung vom Autor) nachgeschaltet, die 7-bit Sequenzen werden wieder auf 8-bit Sequenzen zurückgeführt und die ursprüngliche Länge wird wieder erreicht. Der bei der Entschlüsselung verwendete Schritt aus 72 7-bit Sequenzen 63 8-bit Sequenzen zu generieren, bietet sich hierfür geradezu an.
Aber, dabei gibt es ein Problem: Werden dieselben Schritte verwendet, entsteht anstatt eines Chiffretextes wieder der ursprüngliche Klartext. Es muss ein zweiter Weg gefunden werden. Die Lösung besteht in Folgendem: Die Ziffern des Zahlensystems zur Basis 128 werden als zweites System-Array (128 Zeichen) eingeführt und als Transfer-Zeichen verwendet. Das Verfahren umfasst fünf Funktionen:
1. Klartext --> Schlüssel --> 8-bit XOR-Sequenzen
2. 8-bit XOR-Sequenzen --> bit-conversion --> 7-bit Indexwerte
3. 7-bit Index-Werte --> System-Array (128) --> Transfer-Zeichen
4. Transfer-Zeichen --> bit-regression --> 8-bit Indexwerte
5. 8-bit Indexwerte --> ASCII-Alphabet --> Chiffretext
Ziffern des Zahlensystems zur Basis 128:
0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz&#
@{|}
(definiert vom Autor, nicht standardisiert)
Die 7-bit Sequenzen der Ziffern (Transfer-Zeichen) werden zu einer Bit-Folge zusammengefasst, die dann wieder in 8-bit Sequenzen aufgeteilt wird. Jede 8-bit Sequenz als Indexwert wird im ASCII-Alphabet gesucht und zum Chiffretext verbunden.
Der Pseudo-Code zeigt die Zusammenhänge wie folgt:
FOR K=1 TO LEN(Konversion)
Ziffer = MID$(Konversion,K,1)
CALL SystemNachSystem (128,2,Ziffer,BinZahl)
Sequenz7bit = Sequenz7bit + BinZahl
NEXT K
FOR I=1 TO LEN(Sequenz7bit) STEP 8
Digit = MID(Sequenz7bit,I,8)
CALL SystemNachDez (2,Digit,Dezimal)
Zeichen = CHR$(Dezimal)
Chiffretext = Chiffretext + Zeichen
NEXT I
Zum Testen können Sie sich das Demo-Programm CypherRE.exe
(entspricht: Cypher92) herunter laden und einmal selbst ausprobieren.
Ein weiterer Verschlüsselungsschritt "bit exchange BE"" besteht in einem Austausch der einzelnen Bits eines digitalen Zeichens (Variation der 8 Bits eines Bytes). Dabei ist die Reihenfolge der variierten Bits beliebig, nur jedes Bit muss seinen Wert behalten:
In dieser Operation gibt der Anwender die Bitfolge 1 bis 8 in einer von ihm beliebig gewählten Reihenfolge ein (geschriebene Folge der Bits im binären Zahlensystem im Gegensatz zur Zählfolge in der Bittechnologie).
Klartext Byte: a
binär: 01100001
Bitfolge: b1, b2, b3, b4, b5, b6, b7, b8
Codetext: ac
gewählte Bitfolge: b7, b2, b3, b4, b8, b1, b6, b5
binär: 01101000
Codetext Byte: h
Die Bits des Klartextzeichens a werden wie folgt getauscht:
Der Anwender gibt alternativ seine gewählte Bitfolge ein.
Das folgende Beispiel substituiert das Klartextwort: "Welt"
Klartext Bitfolge: 1 2 3 4 5 6 7 8 Klartext: ... Welt ... dezimal: 87 101 108 116 binär: 01010111 01100101 01101100 01110100 Eingabe Bitfolge: 7 2 3 4 8 1 6 5 binär: 11011010 01101010 01100011 01110010 dezimal: 210 106 99 114 Codetext: ... jcr ...Der "Bit-Austausch" allein ist noch nicht hinreichend sicher. Er muss zusätzlich noch mit einem weiteren Verschlüsselungsschritt kombiniert werden, am besten in der Kombination: Bit-Exchange -Bit-Konversion (Cypher28).
Im Hinblick auf die Variationen der 8 Bit eines Bytes ergeben sich insgesamt 8! = 40320 Möglichkeiten unterschiedliche Programme zu gestalten. Für den Fall, dass Klartext Bitfolge und Austausch Bitfolge identisch sind, ist "bit exchange BE" natürlich unwirksam und es geschieht nur eine einfache "bit conversion" (Cypher13).
Schematisch zeigt sich folgender Ablauf:
Der Schalter S in der vorstehenden Skizze schaltet von manueller Eingabe auf dynamische Generierung der Folge
um. Bei manueller Eingabe muss der Empfänger natürlich dieselbe Bitfolge eingeben wie der Sender.
Anstelle der manuellen Eingabe kann das Programm auch wahlweise in festgelegten Klartextabständen (7 bis 84 Bytes) die Code Bitfolge als "dynamische Parameter" (Variable Delta) aus der jeweiligen BASIC VARIATION oder CypherMatrix ableiten. Die Kontraktion (Abschnitt C,2,c) wird mit MODULO 8 vorgenommen und zur Bitfolge verdichtet. Die Bitfolge wechselt dann mit jedem Durchlauf (Zyklus) des Programms.
Beispielsweise erzeugt das Programm Cypher28 mit zwei verschiedenen Start Sequenzen - die nur in einem Bit abweichen - folgende Bitfolgen in den ersten 7 Durchgängen :
Start Sequenz 1: Am 12.August hat es in München nur geregnet
Start Sequenz 2: Am 13.August hat es in München nur geregnet
binär: 2 = 00110010
binär: 3 = 00110011
Zyklus Start Sequenz 1 Start Sequenz 2
1 3 7 8 6 4 1 2 5 1 8 6 5 4 7 2 3
2 1 5 2 6 8 7 3 4 3 8 1 2 4 5 6 7
3 1 2 3 4 5 6 7 8 2 1 4 8 5 6 7 3
4 6 1 3 7 8 2 4 5 4 8 1 3 5 6 7 2
5 1 6 4 8 3 2 7 5 6 4 8 5 2 1 3 7
6 1 2 3 4 8 5 6 7 6 3 2 1 4 7 5 8
7 6 3 8 4 5 7 1 2 5 1 7 8 4 2 6 3
8 . . . . . . . . . . . . . . . .
Mit der gleichen Technik können auch 16-, 32-, oder 64-bit in ihrer internen Reihenfolge dynamisch
ausgetauscht werden.
Um die Technik einmal selbst zu testen, können Sie sich das Demoprogramm CypherBE.exe
(entspricht: Cypher28) auf Ihren Rechner holen und einige Texte probeweise verschlüsseln.
Der Austausch von Bits erstreckt sich nicht nur auf ein einzelnes Byte, mit derselben Technik kann der Austausch von Bits auch auf eine Serie von Bytes erweitert werden, wie dies beispielsweise auch den herkömmlichen "S-Boxen" mit 64 Bit zugrunde liegt.
Im Folgenden werden die einzelnen Bits in aufeinander folgenden vier Bytes
dynamisch ausgetauscht.
Als Beispiel das Wort: Welt:
Der Austausch der Bits erstreckt sich wahlweise auf 4 bis 32 Bytes (Cypher55). In den ersten Durchläufen erzeugt die Operation für jeweils 4 Bytes folgende 32-bit Folgen:
22 14 15 16 11 30 28 6 18 23 17 2 19 13 1 4 20 31 21 29 5 24 7 8 32 9 10 12 25 26 27 3 13 10 28 4 8 31 2 19 5 14 6 21 3 15 16 18 7 17 11 25 20 22 23 24 9 26 32 12 27 29 30 1 5 14 18 19 15 12 28 10 29 6 1 26 23 8 31 9 13 32 11 27 7 16 2 17 20 24 21 22 25 30 3 4 30 14 12 21 11 25 20 9 17 24 2 8 16 29 5 31 1 15 23 28 18 32 19 3 4 6 22 26 27 7 10 13 25 8 23 26 24 27 7 17 3 9 30 20 15 28 4 14 10 11 18 32 29 2 31 1 21 22 5 6 12 13 16 19 27 26 12 6 30 11 4 13 7 14 31 9 29 32 1 8 5 15 10 2 3 16 28 17 18 19 20 21 22 23 24 25 30 22 3 10 9 11 26 18 8 13 19 27 4 14 15 16 12 28 5 21 24 29 31 20 17 23 25 32 6 1 2 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .In Programmen mit Einbindung der bit-conversion (C2) (Cypher56 bis Cypher58) muss die Byte-Folge mindestens 7 Bytes (oder ein Vielfaches von 7) betragen. Um den Austausch der Bits selbst zu testen, können Sie sich das Demoprogramm CypherSB.exe (entspricht: Cypher57) auf Ihren Rechner holen und einige Texte probeweise bearbeiten.
Bei längerer und intensiver Beschäftigung mit der Materie kommen immer noch neue Möglichkeiten ins Visier. Zum Beispiel: bit crossing, eine weitere Operation als Ergänzung zu den bereits oben vorgestellten Kombinationen zur Durchführung von Verschlüsselungen:
Der zu verschlüsselnde Klartext wird in Blöcke von jeweils 7 (oder einem Vielfachen von 7) Zeichen geteilt und die 8 Bits jedes einzelnen Zeichens werden in einem Array (Matrix mit 7x8 Bits) gespeichert. Darstellung am Klartextblock "Francis":
char ASCII Array
8-bit
F 70 01000110
r 114 01110010
a 97 01100001
n 110 01101110
c 99 01100011
i 105 01101001
s 115 01110011
Dann nimmt das Verfahren die 7 Bits gleicher Spalten, formt sie kreuzweise um in 7-bit Zeilen,
die - in dezimale Zahlen umgewandelt - als Index (+1) - für die im Geheim-Zeichen-Array (1...128)
gespeicherten Chiffretext-Zeichen verwendet werden.
7-bit Index Chiffre-Alphabet
(+1) hex char
Sequenz 1 0000000 1 95
2 1111111 128 99
3 0111111 64 7A z
4 0100001 34 CF
5 0001010 11 7C |
6 1001000 73 C0
7 1101101 110 C1
8 0010111 23 61 a
Die Entschlüsselung geht den umgekehrten Weg. Durch die überkreuzende Verschiebung (crossing) der einzelnen
Bits und die Verkürzung von 8-bit Sequenzen auf 7-bit Indexwerte wird der gleiche Sicherheitseffekt
erreicht, wie im Falle der bit conversion. Insbesondere in Verbindung mit den bereits oben erläuterten
Operationen sind weitere Verschlüsselungen möglich.
Als nächstes werden Substitutionen erläutert, die auf dem Zahlensystem zur Basis 256 aufbauen. In Ermangelung genormter Ziffern dienen die Zeichen des erweiterten ASCII-Zeichensatzes als Grundlage.
Da der Klartext, soweit er zu verschlüsselnde Nachrichten enthält, in den Zeichen des erweiterten
ASCII-Zeichensatzes dargestellt wird, können diese Zeichen auch als Ziffern im Zahlensystem zur Basis 256
verwendet werden. Insoweit wird jedem Zeichen des Klartextes eine bestimmte Ziffer 0 bis 255
zugeordnet. Die folgende Tabelle zeigt die Verknüpfung der einzelnen Ziffern der Basis 256 mit den Zeichen des Klartextes:
(definiert vom Autor, nicht standardisiert)
Zur Verschlüsselung wandelt das Verfahren das Klartext-Zeichen als Ziffer im Zahlensystem zur Basis 256 in den entsprechenden Dezimalwert um, der dann als Index das in der aktuellen CypherMatrix gespeicherte Zeichen holt und seriell zum Chiffretext verbindet.
Als Beispiel das Wort: Basis
Position Matrix
Klartext 256 element
B 11
a 37 P
s 55 v
i 45 "
s 55 v
Ein Nachteil des Verfahrens ist schon aus diesem kleinen Beispiel ersichtlich: Innerhalb eines Klartext-Blocks (z.B. 21 Zeichen) werden
gleiche Zeichen in gleiche Chiffrezeichen umgewandelt. Um sichere Ergebnisse zu erzielen, muss die Operation noch mit einem oder mehreren
Verschlüsselungsschritten kombiniert werden. Im Prinzip sind dafür alle hier vorgestellten Verfahren geeignet.
Um Verschlüsselungen mit Hilfe des Zahlensystems zur Basis 256 zu testen, können Sie sich das Demo-Programm
"Cypher98.exe" herunter laden und selbst ausprobieren. Sie können auch das Programm
"NumberAD.exe" zur Umwandlung von
Zahlen im Zahlensystem zur Basis 2 bis zur Basis 256 anfordern und damit arbeiten.
Ihre Systemdateien werden dadurch nicht berührt.
Im Gegensatz zu den bisher vorgestellten Bit- und Byte-Substitutionen besteht der folgende Verschlüsselungsschritt aus einer Byte-Transposition BT in Form einer Transposition von Bytes in definierten Blöcken.
Der Klartext wird in Blöcke der Länge N (7 bis 70 Bytes: jeweils ein Vielfaches von 7) geteilt. Jedes Byte wird mit seiner Position im Block bewertet und in einem Array (Vektor der Länge N) gespeichert. Das Verfahren generiert in jedem Zyklus aus der GRUND-VARIATION eine periodische Zahlenfolge in der Länge des jeweiligen Blocks durch MODULO N (z.B: MODULO 21, vgl. Abschnitt D,1,b). Die permutierte Zahlenfolge steuert die neue Verteilung der Bytes im Array, so dass eine gründliche Vermischung der einzelnen Bytes stattfindet.
Mit der Start-Sequenz: Baron Münchhausen reitet über den Bodensee, dem Klartext
"HESSE.TXT" und einer Blocklänge von N = 21 (Delta: variabel) ergeben sich für die ersten Durchläufe folgende Zahlenfolgen:
7 8 15 11 9 16 2 4 20 5 14 12 19 10 13 1 3 6 17 18 21
6 19 5 2 7 4 8 20 9 13 16 11 10 12 21 14 15 17 18 1 3
17 4 5 15 3 18 20 1 10 7 13 11 6 19 8 21 9 12 14 16 2
9 2 10 5 16 14 3 4 17 11 20 8 6 18 7 12 13 15 19 21 1
21 18 16 15 1 11 19 17 20 2 9 12 10 3 6 7 14 13 4 5 8
. . . . . . . . . . . . . . . . . . . . .
Die Transposition BT kann anschließend mit weiteren Operationen kombiniert werden. Im vorliegenden Beispiel
wird zunächst eine Substitution dyn24 vorgenommen und dann das Ergebnis mit einer
Bit-Konversion zum Chiffretext erweitert (Cypher53).
Der Beginn der Datei "HESSE.TXT" mit einer gewählen Blocklänge von 21 Bytes lässt die Zusammenhänge wie folgt erkennen:
Als Siddhartha den Hain verließ, ......
Substitution dyn 24
>Hexadezimale Substitution dyn24<
DB BA B5 B5 B3 B7 C8 BD B2 3B 33 B7 B4 B3 3E C8 47 C8 C8 B3 C8
>Bit-Konversion<
8-bit dyn24-Sequenzen
11011011 10111010 10110101 10110101 10110011 10110111 11001000
10111101 10110010 00111011 00110011 10110111 10110100 10110011
00111110 11001000 01000111 11001000 11001000 10110011 11001000
7-bit Sequenzen nach der Konversion
1101101 1101110 1010110 1011011 0101101 1001110 1101111 1001000
1011110 1101100 1000111 0110011 0011101 1011110 1101001 0110011
0011111 0110010 0001000 1111100 1000110 0100010 1100111 1001000
>Hexadezimale Werte der Konversion<
6D 6E 56 5B 2D 4E 6F 48 5E 6C 47 33 1D 5E 69 33 1F 32 08 7C 46 22 67 48
>Chiffretext<
WT$irUJi1J4:C
Als Beispiel einer dynamischen Transpositions-Verschlüsselung steht Ihnen das Programm
CypherBT.exe (entspricht: CYPHER53) als Download zur Verfügung. Eine Auswirkung auf Ihre System-Dateien tritt nicht ein.
One-time-pad ist eine vollkommen sichere Verschlüsselung, die bereits 1917 von Joseph Mauborgne und Gilbert Vernam erfunden wurde (bekannt als Vernam Chiffre) [#19]. Die einzige Schwierigkeit besteht jedoch darin, die Schlüsselfolge, die genau so lang sein muss, wie der Klartext, sicher mit dem Empfänger auszutauschen [#20]. Mit dem hier beschriebenen Verfahren kann dieses Problem ohne Schwierigkeiten gelöst werden. Die Schlüsselfolge wird am besten mit dem Dynamic Number Generator (Abschnitt: D,1,a) erzeugt.
Wenn bei Sender und Empfänger mit derselben "Start-Sequenz" eine identische Schlüsselfolge generiert wird, ist ein Austausch des Schlüssels nicht mehr erforderlich. Die Datei DEVICE01.OTP (vgl. SERIES01.RND) kann auf der Festplatte gespeichert oder - wie zu empfehlen ist - auf einer CD-ROM (Schlüssel CD) gebrannt werden. Der Empfänger erhält dann eine Kopie der CD.
Die folgende Skizze zeigt eine schematische Übersicht der kryptographischen Zusammenhänge:
Zur Verschlüsselung von Klartexten muss ein bestimmtes Offset gewählt werden (z.B. 7654), um an dieser Stelle mit der XOR-Verknüpfung zu beginnen. Die aktive Schlüsselfolge wird dann als Teil der Schlüsseldatei ab dem bezeichneten Offset entnommen. Dadurch wird erreicht, dass der zu verschlüsselnde Klartext genau so lang ist, wie die Schlüsselfolge (one-time-pad). Die verbleibende Spanne zwischen Offset und Ende der Schlüsseldatei muss natürlich länger sein als die Länge des Klartextes. Anderenfalls könnte der Schlüssel nicht genau so lang sein, wie der zu verschlüsselnde Klartext [#21]. Ein Beispiel:
Länge der Schlüsseldatei: 1.280.000
Länge des Klartextes: 380.561
----------------------------------------
maximaler Offset: 899.439
gewähler Offset. 7.654
Der Empfänger muss eine identische Schlüsseldatei erzeugen oder aber
die Schlüssel-CD verwenden. Der Entschlüsselungsvorgang beginnt am selben Offset
mit der XOR-Verknüpfung von Chiffretext und Schlüsselbytes. Der Offset
sollte allerdings von Zeit zu Zeit gewechselt und zwischen Sender und Empfänger auf
sicherem Wege ausgetauscht werden. Als Beispiel zum selber testen können Sie sich die
nach diesen Grundsätzen verschlüsselte Datei: Message7.zip
auf Ihren Rechner holen und versuchen, sie zu entschlüsseln (Start Sequenz und Text).
Auf den Schlüssel kann während des gesamten Verschlüsselungsvorgangs zugegriffen werden. Soll ein kurzer Abschnitt im Chiffretext getrennt entschlüsselt werden und wird dazu seine Position ab Beginn des Chiffretextes ermittelt, ist ein wahlfreier Zugriff möglich ohne dass erst der gesamte Text entschlüsselt werden muss. Bei der XOR-Verknüpfung stehen Chiffretext und Klartext zueinander im Verhältnis 1:1, so dass nur der Abstand (in Bytes) vom Beginn des Chiffretextes bis zur gewünschten Position zu ermitteln und dem Offset des Schlüssels hinzuzuzählen ist:
Position im Chiffretext: 987
gewählter Offset: 7.654
------------------------------------
Position im Schlüssel: 8.641
Werden dann Chiffretext und Schlüssel ab den ermittelten Positionen miteinander
XOR-verknüpft, kann der betreffende Ausschnitt entschlüsselt und gelesen werden.
Im Falle einer Erweiterung durch "Bit-Konversion" ist allerdings ein wahlfreier Zugriff
nicht mehr möglich.
Das "One-time-pad" Verfahren hat zwei gravierende Nachteile: Der Schlüssel - der genau so lang sein muss, wie die zu verschlüselnde Nachricht - muss zwischen Sender und Empfänger sicher ausgetauscht und jeder Schlüssel darf nur einmal angewendet werden. Mit dem "Multi-time-pad" Programm (Bezeichnung vom Autor) lassen sich diese Nachteile auf einfache Art vermeiden.
Das Programm arbeitet auf Basis des CypherMatrix Verfahrens. Eine "Start Sequenz" mit im Prinzip 42 Zeichen (hier allerdings mit 48 Zeichen festgelegt) generiert in jeder Runde von 36 Bytes Klartext synchron und unbegrenzt einen dynamischen Schlüsselvorrat und ein eigenes Runden-Alphabet mit je 256 ASCII-Zeichen. Die "Multi-time"-Eigenschaft wird dadurch erreicht, dass bei gleichbleibender "Start Sequenz" Sender und Empfänger zusätzlich einen gemeinsamen UserCode (Zahl zwischen 1 und 999) eingeben. Infolge geänderter Parameter bewirkt der "UserCode" einen völlig anderen Verlauf des Verfahrens. Von Fall zu Fall muss dann nur noch der anzuwendende "UserCode" ausgetauscht werden.
Die Zeichen des Klartextblocks (36 Zeichen) werden seriell durch ein anderes Zeichen aus dem
Runden-Alphabet ersetzt (structure changing), der ersetzte Block wird dann einer Substitution dyn24
unterworfen und anschließend mit einem aus dem Runden-Vorrat entnommenen partiellen
Blockschlüssel XOR-verknüpft (Cypher82).
Das folgende Schema zeigt den Verlauf:
Für die Entschlüsselung wird der Verlauf umgekehrt. Klartext und Chiffretext sind stets gleich lang, so dass Längenkongruenz gegeben ist. Mithin unterliegt das Verfahren den bekannten Angriffszenarien. Da jedoch eine dreifache Kombination von Verschlüsselungsschritten vorliegt, wird sich nach ausgiebiger Prüfung bestimmt ein sicheres Verfahren bestätigen.
Sie können sich das Demoprogramm CypherMT.exe
(entspricht: Cypher82) auf Ihren Rechner holen und das Verfahren einmal selbt prüfen.
E. Vergleich mit herkömmlichen Verfahren
Die heute aktuell angewandten Verschlüsselungsverfahren arbeiten fast alle
auf der Basis einer einheitlichen Funktion (one way function) mit
Bit Manipulationen. Das CypherMatrix Verfahren dagegen mit zwei
getrennten Funktionsbereichen (Generator und Codierfunktion) und drei
Einweg-Funktionen (Positionsgewichtung, Expansion, Verdichtung zur Grund-Variation), sowie
weiteren integrierten Operationen (X,Y,C2,E,B4,CR,BT,SBE). Das Verfahren arbeitet ausschließlich
mit einfacher Mathematik, MODULO Rechnen und höheren Zahlensystemen (Byte-Technologie).
Die folgende schematische Darstellung zeigt die Zusammenhänge:
In der Darstellung bedeuten:
pi = Klartextzeichen
i = Position im Klartext
k = Schlüssel
ci = Chiffrezeichen
St = Start Sequenz
n = Verfahrensschritt (Textblock)
mn = Matrix Schlüssel
kn = Blockschlüssel
An = Chiffre Alphabet
cii = Chiffrezeichen
In der Darstellung der aktuellen Verfahren bleiben Vorgänge innerhalb der
Funktion - insbesondere Feistel-Schritte und S-Boxen - aus Vereinfachungsgründen
unberücksichtigt. Die Verschlüsselung (Codierfunktion) erstreckt sich
insgesamt auf alle Vorgänge von der Eingabe von pi bis zur Ausgabe
von ci:
ci = f (pi,k)Der Generator im CypherMatrix Verfahren erzeugt für jeden Textblock pn (z.B. 63 Zeichen) eine Matrix mit 16x16 Zeichen. Aus dieser Matrix werden die zur Verschlüsselung erforderlichen Variablen kn und An sowie der Matrix-Schlüssel mn zur Rückkopplung auf den Eingang und Steuerung des nächsten Blocks entnommen. Die Verteilung der Elemente in der Matrix ist daher abhängig vom Matrix-Schlüssel, der aus der jeweils vorhergehenden Matrix abgeleitet und damit ursächlich allein von der Start Sequenz St bestimmt worden ist:
kn = fx (St)
An = fy (St)
Zwischen kn und An besteht kein funktionaler Zusammenhang. Die
Codierfunktion stellt sich daher wie folgt dar:
cii = f (pn,kn,An)Da kn und An beide ursächlich von St abhängen, verkürzt sich die Codierfunktion auf:
cii = f (pn,St)Die Start-Sequenz St steuert den gesamten Verschlüsselungsvorgang.
Bei der Entschlüsselung geht das Verfahren den umgekehrten Weg:
Mit Eingabe der Start-Sequenz erzeugt der Generator einen identischen Verlauf des gesamten Prozesses beim Sender und beim Empfänger und damit auf beiden Seiten inhaltsgleiche Matrizen und Steuerungsparameter. Die Variablen An und kn in der Decodierfunktion
pi = f (cii,An,kn)
pi = f (cii,St)
führen dann zum Klartext pi zurück.
F. Kryptanalyse des Verfahrens
Zwischen herkömmlichen Bit-Verschlüsselungen und dem hier vorgestellten Verfahren besteht ein bemerkenswerter Unterschied: Im ersten Fall wird nur die Struktur der Bits verändert. Die Anzahl der Bits im Klartextzeichen (Input) und im zugehörigen Chiffretextzeichen (Output) bleibt grundsätzlich gleich (8-bit). Es liegt eine Längenkongruenz vor. Insoweit besteht ein einheitliches Ordnungssystem für die gesamte Verschlüsselung: ci = f (pi). Der verschlüsselte Text hat daher auch gewisse Informationen über den zugrunde liegenden Klartext [#7].
Im zweiten Fall bei zusätzlicher "Bit-Konversion" besteht kein einheitliches Ordnungssystem. Die Verbindung zwischen Klartext (pi) und Chiffretext (cii) wird mit drei getrennten Funktionen hergestellt:
c = f [f3, f2, f1]
f1 = "Klartext-Bits" XOR-verschlüsselt mit dem "Block-Schlüssel",
f2 = Konversion von XOR-verschlüsselten 8-bits in 7-bits "Index-Werte"
f3 = 7-bits Index-Werte für die Positionen der Zeichen im
Chiffretext-Alphabet.
Dabei sind die Chiffretext-Zeichen als Ergebnis der zweiten Funktion ("Index-Werte") aber nur "pointer"
(Eingaben für die dritte Funktion) zu den entsprechenden Positionen im Chiffretext-Array beim Empfänger.
Die "pointer" enthalten jedoch keinerlei Informationen über den Klartext. Wenn die "verschlüsselte Nachricht" demnach keine Informationen über den ursprünglichen Klartext trägt, ist der Geheimtext für jeden Angreifer eigentlich bedeutungslos. Datentechnisch vollzieht sich ein "coding by pointers" [#8]. Der einzig mögliche Zugriff besteht nur noch über die Start-Sequenz und den Nachbau der richtigen CypherMatrix (Verschlüsselungs-Gebäude als Cipher-Device).
Versuche aus dem Chiffretext irgendwelche Rückschlüsse auf den Klartext zu erhalten, setzen voraus, dass beide Bereiche sich auch vergleichen lassen. Insoweit muss ein einheitliches Ordnungssystem bestehen, das sowohl im Klartext als auch im Chiffretext wirksam ist. Für den geschriebenen Text sind das Syntax und Entropie der Sprache. Für die digitale Darstellung der Zeichen als Input und Output sind das die Bit-Strukturen.
a) Kein einheitliches Ordnungssystem
Zu den Auffälligkeiten der Sprache zählen Wiederholungsmuster und Wortkombinationen,
Häufigkeitsstrukturen und Bigramme [#9]. Eine Analyse anhand dieser Merkmale setzt
allerdings voraus, dass Klartext und Chiffretext zueinander im Verhältnis 1:1 stehen,
d.h. dass für jedes Klartextzeichen ein bestimmtes Chiffretextzeichen vorhanden sein
muss. Diese Bedingung ist im vorliegenden Verfahren nicht erfüllt. Die bit-conversion
führt zu 8 Chiffretext-Zeichen aus 7 Klartext-Zeichen. Außerdem
enthält das eigenständige Chiffretext-Alphabet nur 128 Zeichen, während
das Klartext-Alphabet 256 Zeichen umfasst. Für Gesetzmäßigkeiten im Klartext
ist hier im Chiffretext kein Raum.
Zu den bekanntesten Angriffen auf verschlüsselte Nachrichten gehören Strukturanalyse, "known plaintext attack",