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 Basisfunktion
Aus den vorstehenden Überlegungen ist das Verschlüsselungsverfahren CypherMatrix® (Bezeichnung vom Autor) entstanden. Der Name CypherMatrix beruht auf der Besonderheit des Verfahrens, eine Matrix als Ergebnis zu erzeugen. Cypher wird mit "y" geschrieben, weil Kryptographen seit Jahrhunderten ältere Formen und Zeichen verwendet haben und das hier vorgestellte Verfahren als Zeichen - ungeachtet moderner Techniken - auch nur Bytes verwendet und so an die Geschichte der Kryptographie erinnern soll. Über Verschlüsselungen hinaus zeigt sich das CypherMatrix Verfahren als universielle Basisfunktion, die in vielen Bereichen der Kryptographie als "Codiermaschine" eingesetzt werden kann (Artikel: Kryptographische Basisfunktion in Byte-Technik
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 erhalten einen Eindruck von dem Generator im folgenden Schaubild:
1. General-Schlüssel: Start-Sequenz
Die kryptographische Basisfunktion - 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 62: fhVkcQn5E
Hashwert Basis 16: 20 59 1C 49 0D EE 18
Hashwert Basis 10: 9 105 177 274 347 032
Start Sequenz 2: Mit dem Hut in der Hand durch's ganze Lane
e = 0110 0101
Hashwert Basis 62: eg9dNdSRh
Hashwert Basis 16: 1F 8E 2F 96 7D 14 BD
Hashwert Basis 10: 8 882 059 317 417 149
(Hashwerte sind mit dem Programm "CMHash.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 BASIS-VARIATION
Um die Funktions-Variablen der Hash-Funktions-Reihe wieder auf dezimale Größen zurückzuführen, werden seriell jeweils drei Ziffern der Reihe in jeder Runde mit MODULO 256 in dezimale Zahlen 0 bis 255 (ohne Wiederholung) umgewandelt und als BASIS-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 BASIS-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:
BASIS-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 BASIS-VARIATION bezeichnet wird.
f: Start-Sequenz ---> BASIS-VARIATIONDie BASIS-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 BASIS-VARIATION direkt auf die ASCII-Werte der Zeichen bezogen werden. Aus den Zahlen der BASIS-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)) BASIS-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 BASIS-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
Die bisherigen Erläuterungen beziehen sich nur auf einen Durchlauf. Um die Funktion auf einen allgemein einsetzbaren kryptographischen Mechanismus zu erweitern, wird für jeden Durchlauf eine neue Startsequenz - Matrix-Schlüssel - aus der laufenden CypherMatrix herausgezogen und auf den Beginn der Funktion zurückgeführt ("loop"). Damit wird der nächste Durchgang initialisiert und die Funktion wird erneut durchlaufen. Auf diese Weise entsteht eine unbegrenzte Anzahl von Runden. Das CypherMatrix Verfahren entwickelt sich so zu einem allgemeinen Werkzeug, das in fast allen Gebieten der Kryptographie eingesetzt werden kann, sozusagen als " Codier Maschine". Ausführliche Erläuterungen hierzu in der Pdf-Datei Basisfunktion in Byte-Technik.
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.
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 BASIS-VARIATION
verwendet (Continuous) oder
2. die MODULO-Rechnung zur Generierung der BASIS-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 BASIS-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 BASIS-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 BASIS-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 BASIS-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) und
b) finaler Abgriff des Hashwertes aus der letzten CypherMatrix nach
Durchlaufen aller vorherigen Runden (final mode).
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:
Zum Testen können Sie sich das DEMO-Programm CMhashLC.exe herunter laden und alles einmal ausprobieren. Darüber hinaus werden Entwicklung und Arbeitsweise der "CypherMatrix Hash Funktion" 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.
Ein etwas einfacheres Verfahren: "teleCode" als erweiterte Signatur", aber gleichwohl ebenso
sicher, nur ohne Bild und Unterschrift, steht ebenfalls als Artikel und DOWNLOAD zur Verfügung.
Einzelheiten finden Sie in den Artikeln:
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. Im Gegensatz zu den heute üblicherweise verwendeten Algorithmen gehen CypherMatrix Verschlüsselungen eigene Wege. Die Verschlüsselung wird in zwei Bereiche aufgeteilt: Basisfunktion (Generator) und Codierbereich.
Beide Bereiche werden kombiniert, können aber auch getrennt verwendet werden. Aufgabe der Basisfunktion (Generator) ist die zur Verschlüsselung erforderlichen Steuerungsparameter bereitzustellen. Die Verschlüsselung als sysmetrisches Verfahren vollzieht sich im Codierbereich. 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. Die bisher entwickelten Kombinationen sind in der Datei:CM-CypherDe.pdf zusammengefasst.
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 BASIS-VARIATION mit 16 Elementen (Abschn: D,1,b / Modulo 16) 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.
BASIS-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). Bei analytischer Betrachtung vollzieht sich eine Umwandlung von Zeichen im Bitsystem zur Basis 8 in Zeichen im Bitsystem zur Basis 7. Der Vorgang 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 der "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 folgende PDF-Datei.
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.
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.
Das Prinzip der Bit Konversion kann auch auf Umwandlungen von 8-bit-Sequenzen auf 9-bit-Sequenzen angewendet werden, d.h. Umwandlung von Zeichen im Bitsystem zur Basis 8 in Zeichen im Bitsystem zur Basis 9. 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
Eine höherwertige Bit-Umwandlung, und zwar von 8-Bit auf 10-Bit-Sequenzen (Bitsystem zur Basis 8 in Elemente im
Bitsystem zur Basis 10) wird im folgenden Beispiel dargestellt:
In jeder Runde wird zur Durchführung und Steuerung des Programms eine CypherMatrix im Zahlensystem zur Basis 32
generiert.
Basis 32 umfasst die folgenden Ziffern: 0123456789ABCDEFGHIJKLMNOPQRSTUV
Um Expansion und Verdichtung zur BASIS VARIATION voll auszuschöpfen,
muss die Startsequenz länger sein als 42 Bytes. Für unser Beispiel wird folgende Startsequenz gewählt:
Mit der Basisfunktion wird die Startsequenz nacheinander positionsgewichtet,
mit der Hashkonstanten C(k) multipliziert, zur Hash-Funktions-Reihe expandiert, dann mit MODULO 1024
zur BASIS VARIATION verdichtet und als CypherMatrix (GF32^2) definiert. Unser Beispiel liefert
für den ersten Durchlauf folgende Bestimmungsfaktoren und Parameter:
Hash Konstante (Ck): 3843+1=3844
positionsgewichteter Wert (Hk) = 22793584
partieller Hash-Wert (Hp) = 4350474618655
Gesamt-Hash-Wert (Hk+Hp) = 4350497412239
Aus den Hash-Werten gewonnene Steuerungsparameter:
Variante: (Hk MOD 11)+1 = 1 Anfang Verdichtung
Alpha : ((Hk+Hp) MOD 1023)+1 = 474 Chiffre-Alphabet
Beta : (Hk MOD 960)+1 = 305 Block-Schlüssel
Gamma : ((Hp+Code) MOD 944)+1 = 433 Matrix Key
CypherMatrix (GF32^2)
1 OA L5 3N SE 75 3R T9 83 6S 76 1V 8H Q4 08 M1 F6 71 DF C2 A2 AG J3 IC 78 KV BK PT L1 2T B9 VH 7S 32
33 MU LF RC PU 2U NS 1A SD K3 TD M9 JP GJ TN 5B D1 6L 9B SI AJ VI 3T DJ IS KI D5 4I 48 8A SJ 8K B0 64
65 T7 BO GU 79 2B L0 F7 UU OJ BP HR CD 9R Q9 D4 MN 1U GH UQ D6 RN K2 N9 52 SF 4Q 2Q AK P9 G0 20 NP 96
97 7J FS N6 77 TJ RS NM 7N C3 7B NT CO A3 KF S4 J0 PM AM Q3 0A 5H OE BE E2 MO CP M3 SU SV 97 NI 5K 128
129 HS P0 VV 2I UI T0 4M TK T8 7O IL F9 16 R4 IM 0F P8 RB U1 HF 8B VB RI ET EU QK QF 9A T6 TQ AN GT 160
161 1O 7A SL UJ HI DG AO 9K CN UL 41 13 7R B3 53 KQ 7M SK KS UK 6K DD CI VN M2 SM HK QV P1 K1 QN Q7 192
193 F8 HH 3S 1P QI JA 68 GD 5V K9 A4 02 HO U4 BF FE U5 VO 33 CQ LD EI 6J CC 6P J4 UV M4 N8 45 JF 1K 224
225 AQ AR 84 24 ME P2 G1 DB O2 MS M5 UE 37 D7 JH PQ TI FL MQ DH 6A PJ QM GF 6T HG CR 00 8L FN NU HT 256
257 SG EB PV Q8 SA C0 GE HL BU 38 VP 2C L2 7K FU 7P PD AS 21 BJ I0 S6 TV PK CJ KJ 0E BB OK CU HU 3K 288
289 66 17 10 FG JC EH PN S7 23 GG TA 0D PO DR GM 1N TU SN 49 3A SQ 94 FT 4E L6 MG 9E K4 JG BL TB 5A 320
321 CF CH RO 91 O1 JL QA DL 8G RT PL SO AT N5 9N BN QU 0N 98 T4 IB 5I 7V 5C BC JK 3D TE T1 D0 51 E5 352
353 TO IP H3 JN AP LI P3 OQ 5N CV 9O ML R0 RD D2 RE I4 2S DI S5 NC V8 9L DC ED 5J 7Q 6R U2 R1 HA C4 384
385 4J 8E GV 6U UD 40 S9 Q1 SP I7 AD K6 TR QE 2D ON TC LB MT AV UM VM FV JI 87 3E PP TS 3F 8Q LV 54 416
417 NV 4P SB PH V0 0B EA BM U3 N7 RU HV AU O3 6H DT LG G2 2H MK 1M 67 RF 9Q 7C PR 25 8U A9 UN 9I V6 448
449 FK 8O 3U QR NA I1 G7 9T G8 E6 95 L8 J8 KA 7T PS VK FQ RQ 1C N2 E3 36 QS IT UG MR 3V EJ 0G 9M S8 480
481 L7 HP 5T 4A N3 62 3J 6M OH 8I QJ 42 CM RP IQ KE RR ID 34 22 69 MF KL 07 BQ OO EV JJ 0C 5L 0M G9 512
513 H2 7L OS 26 LN BR O5 NQ I8 RJ 6N BS OR 3O 27 DK RV NE A6 6B G3 QT U6 MM 3Q 72 GI NK 0V R2 LJ S0 544
545 55 C1 8J 28 6O HQ PC N4 U7 OL 8M HN 5E UO T2 01 OF MV 6Q JQ 8N 3L 7D CS DM I5 NN G4 PI UH FA 2E 576
577 9F 74 NJ QC 0H I9 29 43 I2 OP UF B1 F4 2F A0 IU H0 6F KK B4 EL B2 HJ TL B5 L3 1Q JM F2 I3 Q0 1J 608
609 OI B6 D8 7U U8 BG MP P4 EF IO BV K5 B7 O4 GK 80 81 DA 44 9P B8 6V UP I6 1F OT 5D OU IA 4C VT QO 640
641 M6 SS R3 6C AA D3 5M RG L9 BA LA NL KM 8R OV LH 46 FI FH CL LC 99 VF C9 0I SH OM S1 4H U0 VJ FJ 672
673 82 LE MI CB TG 03 P7 P5 VL KC BT 8S V1 7E R7 86 T3 85 VQ UR P6 AB L4 D9 RK H1 JO GL US LK VA C5 704
705 A5 PA LL 0J SR IV C7 G5 TP MH BD VR AC O0 QP FM 6G PB U9 RH PE 35 LM JR 2A RL 9C QL 6E TT 70 QQ 736
737 SC CT 4B 04 4T VS 2R PF 2G HM 47 4D UT LR 73 5O C6 3G 09 E0 LO QG HB 0K 88 OB LP 3P ST 7F 4F TF 768
769 89 7G 7H 2J 8P Q5 0L M7 FB 7I DN C8 A7 AH J5 IE 8C LQ CA Q2 LS 2V BH VU 8D N0 LT RM Q6 30 O6 1B 800
801 T5 K7 TH MA JS GN UA 5F DE 8F 9D TM AL 05 4G DO J1 KN DP 4K 4L 8T UB 8V BI UC CE H4 90 2K LU FC 832
833 V2 PG CG IF CK 9S QB DQ N1 2L GO V3 DS S2 K8 NB 56 V4 4R 31 DU QD G6 2M NR 92 GA ND 93 V5 S3 NO 864
865 96 DV 9G O7 E1 A8 KG V7 J2 QH E4 R5 0O 5P OG E7 E8 NF E9 M8 V9 VC 9H O8 5Q IG R6 06 2N VD VE 4N 896
897 VG 0P 9J IN FD 18 R8 IR 0Q R9 0R 0S IH 9U 0T 0U F0 F1 RA 11 9V 12 14 EC H5 1R A1 15 19 II EE EG 928
929 AE EK 1D 4O 1E AF EM 57 KR AI 1G KT 1H EN EO EP 1I MB 1L IJ 1S 1T KB 2O 2P FF IK 4S 32 39 JB 6D 960
961 GP 60 KD EQ 3B J6 3C ER FO 3H 3I 3M ES M0 F3 F5 FP FR J7 4U MC NG 4V JT 50 GB GC GQ 58 MJ 59 GR 992
993 GS O9 NH MD 5G 5R H6 JU 5S 5U H7 OC H8 6I 61 63 H9 HC J9 HD 64 HE JD OD JE 65 JV K0 KH KO KP KU 1024
BlockKey = TUSN493ASQ94FT4EL6MG9EK4JGBLTB5ACFCHRO91O1JLQADL8GRTPLSOATN59NBNQU0N98
Block 10-bit = 111011111011100101110010001001000110101011100110100100100100011111110100100011101010100110101101000001001011101010000100100111000001011101011110101011...
MatrixKey = LGG22HMK1M67RF9Q7CPR258UA9UN9IV6FK8O3UQRNAI1G79TG8E695L8J8KA7TPSVKFQRQ1CN2E336QSITUGMR3VEJ0G9MS8L7HP5T4AN3623J6MOH8IQJ42CMRPIQ
ASCII-set = Q6o:;E I2~[A=%h
Mit Alpha = 474 wird das erste Chiffre-Alphabet wie folgt aus der CypherMatrix herausgezogen:
Basis Alpha = UGMR3VEJ0G9MS8L7HP5T4AN3623J6MOH8IQJ42CMRPIQKERRID342269MFKL07BQOOEVJJ0C5L0MG9H27LOS26LNBRO5NQI8RJ6NBSOR3O27DKRVNEA66BG3QTU6MM3Q
Alphabet = 69sSyZ{MdBϕzt"F|Hu}xGI]~bJ:,7ڢv휶E2N/LKOCaP@^Ԕec3f;wDA4gp$Xh!.iQ0
Hexadezimal
D0 7F D3 36 88 A7 39 BD 8A E3 C2 73 D6 53 82 96
79 5A 8E 7B 4D 64 42 C9 CF 95 7A 74 B5 22 F5 46
B7 7C FA 48 75 D7 7D 78 47 B4 80 EE 49 CB 5D C6
D8 7E E2 F4 62 B3 81 A5 83 4A D9 3A 2C E4 C7 37
AE DA A2 E0 84 76 ED 9C B6 45 F7 32 D1 EA 4E 2F
E5 F3 4C 4B 4F 85 43 D2 61 E6 50 40 5E D4 94 65
63 33 B8 66 A3 3B 77 E7 44 41 34 67 A8 FE C8 70
24 58 86 87 68 21 AA 89 3C 69 E1 E8 51 30 23 AD
ASCII-Alphabet
1 6 9 s S 16
17 y Z { M d B z t " F 32
33 | H u } x G I ] 48
49 ~ b J : , 7 64
65 v E 2 N / 80
81 L K O C a P @ ^ e 96
97 c 3 f ; w D A 4 g p 112
113 $ X h ! < i Q 0 # 128
Für die Verschlüsselung verwenden wir die Worte von Hermann Hesse aus der Datei: HESSE.TXT (vgl. Abschnitt 4,b)
Klartext: Als Siddhartha den Hain verließ, in ...
Hex: 41 6C 73 20 53 69 64 64 68 61 72 74 68 61 20 64 65 6E 20 48 61 69 6E 20 76 65 72 6C 69 65 E1 2E 20 ...
8-bit: 01000001 01101100 01110011 00100000 01010011 01101001 01100100 01100100 01101000 01100001 01110010 ...
10-bit: 0100000101 1011000111 0011001000 0001010011 0110100101 1001000110 0100011010 0001100001 0111001001 ...
Basis 32: 85 M7 68 2J D5 I6 8Q 31 E9 ...
BlockKey: TU SN 49 3A SQ 94 FT 4E L6 ...
10-bit: 1110111110 1110010111 0010001001 0001101010 1110011010 1001001000 0111111101 0010001110 1010100110 ...
XOR: 1010111011 0101010000 0001000001 0000111001 1000111111 1101100010 0011100111 0011101111 1101101111
7-bit: 1010111 0110101 0100000 0010000 0100001 1100110 0011111 1110110 0010001 1100111 0011101 1111101 ...
Index: 87+1 53+1 32+1 16+1 33+1 102+1 31+1 118+1 17+1 103+1 29+1 125+1 ...
Zeichen: y | w F Z " 0 ...
Chiffretext: ҳy|wFZ"0;@LǂHackTM/2krbUU8fj ...
Um die Sensibilität des Verfahrens zu demonstrieren wird ein Bit der Start Sequenz von "0" auf "1" gesetzt, und zwar das letzte Bit im letzten Byte. Im Übrigen bleibt die Start Sequenz unverändert.
n = 11001110
o = 11001111
Für die um 1-Bit geänderte Start-Sequenz berechnet das Verfahren folgende Bestimmungsfaktoren und Parameter:
Hash Konstante (Ck): 3843+1=3844
positionsgewichteter Wert (Hk) = 22797491
partieller Hash-Wert (Hp) = 4352656566236
Gesamt-Hash-Wert (Hk+Hp) = 4352679363727
Aus den Hash-Werten gewonnene Steuerungsparameter:
Variante: (Hk MOD 11)+1 = 3 Anfang Verdichtung
Alpha : ((Hk+Hp) MOD 1023)+1 = 377 Chiffre-Alphabet
Beta : (Hk MOD 960)+1 = 372 Block-Schlüssel
Gamma : ((Hp+Code) MOD 944)+1 = 574 Matrix Key
CypherMatrix (GF32^2)
1 F1 OQ FV 8P T8 4U FM LI 5Q F0 HP KQ 8D 5U K2 G7 2H 1U 08 EJ 40 HQ 9S 9T HR 3L GA O2 2O 31 AK RK 32
33 4S D4 V4 TP H0 OH JU 2U 5L 1L PB KN 8H QC NL ND 2E PC RB Q0 A4 3H J8 K9 D5 US 4L 0P PO 5O QH 4P 64
65 GQ RR 3M 0S MP RC 3S SP CP 7H BF N6 SJ D9 RQ 89 V7 BQ KI 6A G9 J2 TC 66 CF SQ DD MO QE T0 V8 5V 96
97 OI NT V2 0L DK MD E7 PK NU QB G4 QJ NS S0 CQ OJ M3 9M 79 NE 8K SG UE 6Q 3V Q6 TI OU 0U 06 G8 JP 128
129 I5 NR RS NQ EG GG OK PA E6 KP JM O4 UV TF GD 7O 97 P3 OR H9 H7 8E IB VP IG 57 TB R4 3J 5M DL B2 160
161 1V RD AU 09 C0 TJ 1C AS P4 KG EH H4 RL 2R MK 48 6G 0J 1O IR 6M PF TE 3F 0M FA DA IT IF 6L OS V9 192
193 1T 3N LP U4 FT HK CH 07 K7 QK 7E 98 0N TG UT MJ OA 4Q CB F6 HS R3 2L J4 HC OM 86 1P N0 4D NO SE 224
225 4F OB RT 1Q ML EO E1 LT CG UJ IU 5C FE L6 KC JL JA 9I MG LD K3 RU KJ A3 DT TK D6 DB M7 OT 3O T3 256
257 P7 L5 V0 JN NH S8 7I SH L7 DG C2 AV M2 LJ JO 8M 7L BU CV HM KF Q4 2F 0O IC 19 HO 6N 8Q E9 6J FU 288
289 10 21 KA VH 6H JV H1 FI DH OV K5 AH SA 1F 2S B9 RP FJ 1A FK LS 8U J0 G1 PD GB 8N OE 3G VE P8 22 320
321 BT AR 5B I7 M4 8T OL LE U5 UN NI VM 9A 7F DI Q7 99 RG DC 9E M5 NV EI 3D IJ 12 QQ MH OF 9Q V3 FR 352
353 DM P0 QF H8 Q5 4N 4K 6O EL VA 9V 1R UU 2V DF ON VN 4E B4 K0 JK 0C EC VB UO RV L0 LO 4V ME L1 30 384
385 SR FL PP B5 MR IE 1B 1E MM 05 2P I3 41 36 PG 3I 8L GE TL AB D8 M8 0D LK MU HT 2I FF SD U8 0Q DE 416
417 04 2A B3 U6 U7 KR 2T TN OG 1N 83 87 S3 TV PJ 6R KH BE 42 6E DJ VO LG 11 KS 7J VG A8 HU E8 FB HB 448
449 3K QD QM 9F 5N GN 2N 0A UK J9 6I 25 13 CT V5 LH 8O SI S5 2D IH MI 46 L8 6P D7 T4 RE 8V 4R JT EQ 480
481 EA NM 6S 88 AL HI R5 90 RM 82 I8 AN KD ID QN II BR C3 7N TM J1 ES 3B 63 FN P6 JG TD 0R VI P1 0T 512
513 TU TO QA 02 HV 1J JJ M9 9G 32 MN 7P 0H SN VT 94 NA 7A 33 8A IK 3A RH 0V 91 UR L2 BA LR KO G0 2B 544
545 O3 U9 3C E0 PL A9 N1 K6 CU N4 QT O0 I0 67 92 DQ 3P 93 84 JB RO 4M 4B 35 95 A7 CE EV I1 MQ LQ HD 576
577 52 Q1 O1 BV MS B0 FG M6 RN 6T G2 B1 9B 1S JH GC LA IN C1 DN FP HL 3Q 7V 20 PE MA 96 FO CJ Q2 N2 608
609 3E CN EP 1G 3R IV H2 MT M0 1H OO O8 3T K4 LL 8R O6 56 2G S1 7K TH 8J U0 6U KT 3U RI 26 EK 14 KB 640
641 23 UI K1 IL LU O5 4O 62 SF SB 18 HA DR 4T 85 UM KE 74 68 BM 43 RJ CR 5S K8 P5 IM H5 15 NC 9H PH 672
673 69 V6 UA SK G3 2Q I2 QG 27 34 PT TQ HJ TR RA 0B S4 O7 76 L9 VV QO 37 4C CK 71 38 39 AT GF U1 KU 704
705 Q8 A0 9C 16 DO 17 IO 2C 78 MV L3 1D AQ KK AM E4 7U N5 CI O9 KL 7R U2 VQ 9D AA GK ER N3 H6 6V KM 736
737 G5 24 CL CS HE N7 44 SS B6 CM 5P 70 KV A2 45 UL 47 50 IP FQ EB 0E 9J 2J 49 F2 P2 G6 8S T9 51 FS 768
769 LM 5R F3 I4 L4 8F 60 LB GH 2K 28 0F EM 4A I6 9U A1 I9 4G GI OC 4H 4I AO S2 53 DP VC TS H3 OP LC 800
801 4J 5T 1M PI LF 8I QI NN NF 2M PM RF Q3 A5 54 JC LN DS V1 55 1I PQ 61 QL 58 GR S6 59 1K N8 S7 5A 832
833 ST D0 7M BG N9 SL DU S9 8B VD BS LV 6B GJ J3 TT 6C CO SU DV NB QP T1 VF 64 P9 OD VJ 29 E2 MF ED 864
865 PN PR QR GL QS PS SC D1 PU MB 9N 7B NG 9K SM UF 72 5D Q9 U3 PV 5E 0G GM JQ IA QU SO QV EN GO R0 896
897 R1 EE M1 JR R2 VK UB GP 7Q 9L R6 R7 HF HG 8G IQ VR IS 5F UC R8 5G 65 E3 B7 5H SV B8 0I C4 UD 5I 928
929 BB R9 MC ET HH T2 5J NJ 5K 6K 0K 6D J5 73 T5 UG 6F 75 FC E5 J6 J7 77 T6 VL 7C 7D NK UH GS HN D2 960
961 7G NP T7 7S 9O 7T UP VS TA UQ 80 CC F7 JD VU 81 JE JF 00 8C 9P 01 9R 03 A6 AC AD AE AF AG EU EF 992
993 AI D3 AJ JI AP FH BC BD JS BH BI BJ BK BL BN BO BP F4 C5 F5 F8 C6 C7 C8 C9 CA CD F9 FD GT GU GV 1024
BlockKey = K0JK0CECVBUORVL0LO4VMEL130SRFLPPB5MRIE1B1EMM052PI34136PG3I8LGETLABD8M8
Block 10-bit = 1010000000100111010000000011000111001100111110101111110110001101111111101010000010101110000010011111101100111010101000010001100000111001101101111101...
MatrixKey = MQLQHD52Q1O1BVMSB0FGM6RN6TG2B19B1SJHGCLAINC1DNFPHL3Q7V20PEMA96FOCJQ2N23ECNEP1G3RIVH2MTM01HOOO83TK4LL8RO6562GS17KTH8JU06UKT3URI
ASCII-set = ں-A`wa+.q W5z@.&Bn0{_"1}Pޝ~r
Basis Alpha = UORVL0LO4VMEL130SRFLPPB5MRIE1B1EMM052PI34136PG3I8LGETLABD8M80DLKMUHT2IFFSDU80QDE042AB3U6U7KR2TTNOG1N8387S3TVPJ6RKHBE426EDJVOLG11
Alphabet = Ρ`9eN+.YCf0rKȴ=RɮJcǜ]73nϳ!H>,tMV/WiE#咅OQӆ٧o}U2gvIXPZS{ak&p"L?4s1b$d
Hexadezimal
D8 7F A0 B8 9F CE A1 60 9B F5 39 65 4E 2B 2E D6
59 43 81 66 30 72 B5 4B A8 C8 B4 3D 52 EF 8D C9
AE 4A 63 C6 C7 9C 5D B7 37 83 BF 33 91 6E 82 CF
B3 F8 21 9D F3 F0 48 3E CA EB 2C 74 4D 56 2F B9
57 D4 69 D2 45 23 9E E5 92 85 4F 51 D3 86 A9 D9
A7 A4 6F A2 7D DA CB F6 55 32 67 76 49 58 8E 50
5A 53 7B 84 F7 B6 61 6B C3 F9 26 70 AD F2 22 BE
BA 4C 3F 34 73 CC 31 62 D7 FA 97 FD 24 EA EC 64
Alphabet (ASCII-set)
1 ` 9 e N + . 16
17 Y C f 0 r K = R 32
33 J c ] 7 3 n 48
49 ! H . , t M V / 64
65 W i E # O Q 80
81 o } U 2 g v I X P 96
97 Z S { a k & p " 112
113 L ? 4 s 1 b $ d 128
Chiffre-Text:oaNsU1]vWPeX{ʠpt/N/.Jz+"^ȈAm{l ...
Vergleichen Sie die veränderten Bestimmungsfaktoren und Parameter mit den obigen Daten und bewerten
die Abweichungen. Um einen eigenen Eindruck zu gewinnen, können Sie das Demoprogramm
Cypher3B.exe herunterladen und alles einmal selbst ausprobieren.
Eine weitere höherwertige Bit-Umwandlung lässt sich auch mit 12-Bit Sequenzen und dem Zahlensystems zur Basis 64, bzw. im Bitsystem zur Basis 12 erreichen.
Mit der Basisfunktion erzeugt das Verfahren im Bitsystem zur Basis 12 eine CypherMatrix GF(64^2) mit 64x64 Elementen.
Die hierfür erforderlichen unterscheidbaren 4096 Zeichen werden dem Zahlensystem zur Basis 64
entnommen. Jedes Zeichen besteht aus 2 Ziffern. Das System umfasst die folgenden Ziffern:
Um eine vollständig durchmischte BASIS VARIATION zur erreichen, muss die Start-Sequenz eine Zeichenfolge von mindestens etwa 112 bis 128 Zeichen enthalten. Dazu einige Beispiele:
"Till Eulenspiegel sitzt auf der Zugspitze und raucht Zigarren. In Hinterzarten
steigt er um in den Zug nach Irgendwo" [117 Bytes]
"7 Nordlichter wandern über den großen Belt, weil sie nicht schwimmen können und ihre
wasserdichten Schuhe vergessen haben" [122 Bytes]
"Sven Hedin is sailing around the North Pole in a green nutshell. In Far Rockaway Beach
he changes for the Yellow Submarine" [123 Bytes]
Für die Verschlüsselung der Datei HESSE.TXT und der obigen ersten Start Sequenz "Till Eulenspiegel ..."
ergibt das Verfahren im zweiten Durchlauf die folgenden Bestimmungsfaktoren und Parameter:
Hash Konstante (Ck): 65024+1=65025
positionsgewichteter Wert (Hk) = 1397890543
partieller Hash-Wert (Hp) = 3.88497266464138E+15
Gesamt-Hash-Wert (Hk+Hp) = 3.88497406253192E+15
Aus den Hash-Werten gewonnene Steuerungsparameter:
Alpha : ((Hk+Hp) MOD 3720)+1 = 80 Chiffre-Alphabet
Beta : (Hk MOD 3968)+1 = 3824 Block-Schlüssel
Gamma : ((Hp+Code) MOD 3872)+1 = 3170 Matrix-Key
CypherMatrix GF(64^2) [64x64 Elemente]
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
1 f# u2 tT l# 5i Px jy S5 Fl 0J 4l gQ d7 BO Kq cA .. .. Q& 6q q8 0r F6 MG Vc fP ht Te qq 3T xs KP nz gv 64
65 0p &F 5z 41 VA bT up ds TP JX dC yC ik lj #6 GR .. .. nG ya iM RP nh U2 Ss WX ta mZ #N 49 5f y0 1s I# 128
129 k0 &j pn vw rn #v ka GT vx 5a Bf Nv Mv OY sd 8f .. .. fC Es 9r na Kb Tj Sk yv ai mE 9C 8z Hw 47 iR zF 192
193 &o pX qV Mk 2c Av mD bQ 4s ou Vr Ue dT 2U oi Wa .. .. #j E0 fX 7r pl Og 0T V1 Ri Jx &6 pZ yP Dl D4 m# 256
257 yD Ig Jy JS q9 ZZ En hb GY QP e6 #7 AQ AB aw ZX .. .. yE H1 nZ S6 Ub 02 RM xb LR h& J# x# iF H9 w& w9 320
321 gE eC ED L2 NX 31 Vd m2 PW aX EH Xk 76 x& 2t 4d .. .. oN &O Rf rf SL o3 oj CE pc O5 Hm Uu ab &8 Iw 0Y 384
385 bk Lh Jt wL 9D D& fT Rt R5 xv p9 Th dw Er oo 3O .. .. WT dU Ld NY Hh Gh is V2 KI fS LK jA 5N rB q0 #C 448
449 Hi hz 5g r0 S8 eR dF #O QJ dt &# OB f1 qX 3L &I .. .. Xl wF qx Wr jh qW 87 Q9 v7 M5 fW Bb k# Y9 Ta tx 512
513 Mj pt jO UO &E n0 RV Zf 0e 88 NN Yj os hs hY gp .. .. YC 9& 52 Ho H2 Le QN lX Xi EI ld Q2 YR az Jw fl 576
577 Nl l8 IE VL o5 xW Kv 59 sZ 5n cJ 4A Dq a1 1V J0 .. .. p8 Ab 3j Y8 KX CF W6 FA mN Wt Zg c3 Ah R0 HR bj 640
641 iA HN L9 cX fY mH #E Bi rK j1 DU xT Xz lV N2 Td .. .. Zu gS Bm V& Dr Sn Oi e8 WH 9M Mt KC s& wG ZC kK 704
705 SI qZ Ad nA qR js 2x kO MB &3 Mc go lz j& Z1 Pa .. .. gm 7X #F Jf K6 E4 bi y3 hL uY GF j5 &A AZ 8j 3u 768
769 So 4X 0s d3 lS Kk ha jz Ac Ba bZ 0W d0 A0 K1 on .. .. f6 Yi aA L8 NO li qF pd cS wo 6z s1 j2 RZ IV #L 832
833 CO mu wn EJ Go S& un eD By hR 2y QG P# Z# aS tb .. .. Wf MR iL 9U VM Oq Pp kQ Ft MX yI m1 wM 0& 0B #g 896
897 4D Cl B2 4R XR SK YQ Wg cx 8d uM L3 Ua yA 7T 6Z .. .. 12 4# 6U Ks Kd db 5o TB 4O or IF 3b JK A7 Z& Pi 960
961 1E &Q #m Qp EB Sz 6S v3 0C fz ji sA Hj XN ZP #8 .. .. nH z7 qK x8 wN 9G h4 Vv G2 Hv Fk Sr bN a8 mk lt 1024
.... .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ....
.... .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ....
3073 AA 91 aa WU 9F #K aj XI CA IJ qP mz Sq HH E9 bt .. .. 9N 03 bG 3S oc Zl 2i kz 5l xl dH SB IK 6x x3 Ko 3136
3137 i& SD rq xe #T dM Qa bv Fb Vn 45 eX vm XA Us lq .. .. 85 Qq V0 40 ak lR BN PG 8t CJ yK MW 84 oQ yg #Z 3200
3201 IL 1D ax am s8 HX MA k& Ou eL bb Lo 7J V# oI CQ .. .. 8I CR nN Pe xV zv ES EC XO dz 3G Io GS ZB wj 0L 3264
3265 tW tI co Ll m6 8L Cc XK 6t G6 4v Gd qh Cd 4g Kx .. .. d6 NI WB K# L0 8T zf rr Nf L6 v1 yN EV by fs Hc 3328
3329 Yy yO EE 6C yS 08 3t YF nl 0R wV qi Cq rd ft fu .. .. FD nY ev vq zh dk 5p YM 7G 7L 0I zy mS IQ LE bP 3392
3393 9P 3I Fo jp YG pI Cr lE g5 jQ 7p Of 90 sD Z9 ss .. .. yy lQ UX RS dm VZ H5 jM 1P dn Hf lx 4k FR GM nT 3456
3457 VD m7 i4 1Q WL x4 vG wQ 6w Yh vI RU LH qG pN 1S .. .. AM wx Vp n4 mI XP g7 NC c7 g8 Pf 1b Rk X5 &1 &4 3520
3521 rw Dm Rw jC NK xF 6M 3o e3 xi yV 1e ar UK pK PJ .. .. mK c8 DH yX 5t gR 3K LN Q5 7S Eb hW mL e2 em Ed 3584
3585 PL Rh IR QO LP Gw LQ en RA n9 GA eo DD pT Cz mM .. .. AN DE Fr 5u 1h 4n hC 93 Ee ex Pq h5 DF 3r Ym LZ 3648
3649 Lm DM 7K 3v Tt Yn Ef YV GN yY gb UU 1i jD vT AP .. .. 9K 6N OE nw 4z tJ Ak oL gg Ov 3y gk G3 G7 DN tq 3712
3713 1n vV Qd 7M V7 BW Ep An SW sE ZF Qr gs Qt mP oR .. .. vZ F& XJ P& R6 jN RK FG Fp 1& yq Z8 rv XQ h8 xk 3776
3777 Qv vn BX DT FI hA 21 57 qp yr VG w8 hE va YS Ps .. .. hZ 5K Oz 5S FU td vh 5W Fh G8 hc MC qr qs 25 qt 3840
3841 MF MI G9 R7 7N rI 26 GB MM Vq he i5 U0 rJ 5w xt .. .. GQ vj 2I oT jW jX vp jZ 62 GW O1 rR vt 6W Xg 2j 3904
3905 OA Xt OC nM 2k mg RX np UN UR Xw th nC 2l 63 65 .. .. nq sJ nr 7O 7P G& wY 7R 2u H8 UV xq ns nx t3 wZ 3968
3969 ny oV 2v oW HC HE oY PO UY UZ 7e oZ oa HF HI PP .. .. wc Qg Qw pU Qx R8 RC RJ Y0 U& Rn Ro pV Rp Rv S1 4032
4033 S2 S3 wd S4 SG pW SX rj Si V8 V9 VK VO VQ rm VS .. .. wy x0 Yp xr Yr Ys Yu ZG ZI ZJ ZK ZO ZQ ZT ZV ZW 4096
Das Verfahren verschlüsselt in zwei unterschiedlichen Methoden:Mit dem Parameter Alpha wird in der aktuellen CypherMatrix (4096 Zeichen) ein Offset bestimmt, ab dem 256 Zeichen entnommen und in einem Chiffre-Alphabet gespeichert werden. Das Alphabet wechselt mit jedem neuen Klartext-Block von 84 Zeichen. Mit dem ASCII-Wert des jeweiligen Klartext-Zeichens wird das zugehörige Alphabet-Zeichen angesprochen und zum verschlüsselten Text verbunden.
Als zweite Methode wandelt das Programm zunächst 84 8-Bit Sequenzen des Klartextes um in 56 12-Bit Sequenzen (Bitsystem zur Basis 12), die mit gleich langen Sequenzen des Blockschlüssels XOR verknüpft werden. Diese Sequenzen teilt das Verfahren dann in 96 7-Bit Abschnitte (Bitsystem zur Basis 7), die jeweils als Index das zugehörige Chiffre-Zeichen aus dem Chiffre-Alphabet (Array mit 128 Zeichen) holen und zum Chiffretext verbinden. Weitere Operationen können integriert werden.
Die Sensibilität des Verfahrens zeigt sich, wenn ein Bit der Start Sequenz von "1" auf "0" gesetzt wird, und zwar das letzte Bit im letzten Byte. Im Übrigen bleibt die Start Sequenz unverändert.
o = 1101111
n = 1101110
Hash Konstante (Ck): 65024+1=65025
positionsgewichteter Wert (Hk) = 1395943891
partieller Hash-Wert (Hp) = 3.88528316976116E+15
Gesamt-Hash-Wert (Hk+Hp) = 3.88528456570505E+15
Aus den Hash-Werten gewonnene Steuerungsparameter:
Alpha : ((Hk+Hp) MOD 3720)+1 = 3530 Chiffre-Alphabet
Beta : (Hk MOD 3968)+1 = 1492 Block-Schlüssel
Gamma : ((Hp+Code) MOD 3872)+1 = 3016 Matrix-Key
Vergleichen Sie die veränderten Resultate mit den obigen Bestimmungsfaktoren und Parameter.
Der Aufbau der umfangreichen CypherMatrix GF(64^2) erfordert viel Zeit, sodass das Verfahren relativ langsam arbeitet, aber dafür absolut sicher ist und nicht gebrochen werden kann. Mit einem Programm dieser Art hätte die "one-time-pad" Verbindung zwischen Washington und Moskau während des kalten Kriegs wesentlich kostengünstiger aufgebaut werden können.
Um den Ablauf zu beschleunigen, kann das Verfahren in der Weise modifiziert werden, dass die Erzeugung der CypherMatrix GF(64^2) auf die beiden ersten Durchläufe beschränkt wird. Die in den weiteren Runden errechneten Bestimmungsfaktoren und Steuerungsparameter werden dann auf die CypherMatrix des zweiten Durchgangs bezogen. Bei einem Umfang von 4096 Elementen bleibt eine ausreichende Vielfalt an Variablen erhalten. Die Sicherheit des Programms wird nicht geschmälert. Sie können das Demoprogramm Cypher6D.exe herunterladen und alles einmal selbst testen. Ihre Systemdateien 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
Eine weitere Möglichkeit, den verschlüsselten Text in der gleichen Länge an der bisherigen Position des Klartextes wieder abzuspeichern, bietet auch eine abschließende Rekonversion der 7-bit Sequenzen in 8-bit Sequenzen (CypherAD): Gegenüber dem vorhergehenden Verfahren unterscheidet es sich nur in der Struktur des Arrays(256).
Nach den Darstellungen im Abschnitt C,2,d) Dreifache Permutation stellt sich der Vorgang im Pseudo-Code wie folgt dar:
FOR s=1 TO 3
FOR i=1 TO 16
FOR j=1 TO 16
a = i - j
IF a <= 0 THEN a = 16 + a
SELECT CASE T
CASE 1
Zeichen$=Matrix$(1,I,J)
Matrix$(2,A,J)=Zeichen$
[Element Array(128) = Zeichen$] bit-conversion
CASE 2
Matrix$(3,A,J) =Matrix$(2,I,J)
CASE 3
Zeichen$=Matrix$(3,I,J)
[Element Array(256) = Zeichen$] Rekonversion
END SELECT
NEXT j
NEXT i
NEXT s
1. Klartext --> Schlüssel --> 8-bit XOR-Bytes
2. 8-bit XOR-Bytes --> bit-conversion: Array(128) --> 7-bit Indexwerte
3. 7-bit Indexwerte --> Rekonversion: Array(256) --> 8-bit Chiffretext
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.
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.
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.
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.
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 BASIS-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
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.
E. Bits und Bytes in der Kryptographie
1. Systematisierung der Bitfolgen
Kryptographie ist Schreiben und Lesen von geheimen Informationen mit arteigenen Methoden (Verschlüsselung). Seit Jahrtausenden haben Menschen die Zeichen ihrer Sprache so verändert, dass nur der berechtigte Empfänger in der Lage war, die Information zu entziffern. Dabei bedienten sie sich fast ausschließlich ganzer Zeichen ihres jeweiligen Alphabets.
Als die Computer kamen, hat sich diese Betrachtung geändert. Computer arbeiten in Binärtechnik (Zahlensystem zur Basis 2) Als Folge der elektronischen Technik können sie nur zwei Zustände unterscheiden: "vorhanden" (eine Spannung) oder "nicht vorhanden" (keine Spannung), d.h. in Ziffern des Zahlensystems zur Basis 2: "eins" oder "null". Der Zustand wird allgemein als "Bit" bezeichnet.
Der Computer kann technisch nur "Bitfolgen" erzeugen (1 bis oo). Sie sind in ihrer Menge unbegrenzt. Es liegt ein vergleichbares Phänomen vor, wie bei der Menge aller Zahlen. Um mit Bitfolgen systematisch zu arbeiten, Zusammenhänge und Gesetzmäßigkeiten zu erkennnen und Programme zu gestalten (insbesondere auch Verschlüsselungen) müssen die Bitfolgen systematisiert werden, d.h. skalieren und in definierte Abschnitte (Einheiten) teilen. Alle gleichen Bitlängen, wie z.B. 4-bit, 7-bit, 8-bit, 12-bit, 16-bit und weitere, stellen Einheiten dar ("Units",8-bit Folgen = "Bytes"). Dafür bietet sich ein Strukturvergleich mit der Zahlentheorie an. Das Bit entspricht der Ziffer, das Byte (bzw. Unit) der Zahl und das Zeichenalphabet stellt die geordnete Menge dar. Entsprechend der Zahlensystematik kann dann beispielsweise für 8-bit Folgen vom "Bitsystem zur Basis 8" gesprochen werden.
Alphabet
Bitfolgen: 1-bit = Bitsystem zur Basis 1 = 2^1 Zeichen 2 Units
2-bit = Bitsystem zur Basis 2 = 2^2 Zeichen 4 Units
4-bit = Bitsystem zur Basis 4 = 2^4 Zeichen 16 Units
7-bit = Bitsystem zur Basis 7 = 2^7 Zeichen 128 Units
8-bit = Bitsystem zur Basis 8 = 2^8 Zeichen 256 Bytes
11-bit = Bitsystem zur Basis 11 = 2^11 Zeichen 2048 Units
16-bit = Bitsystem zur Basis 16 = 2^16 Zeichen 65536 Units
32-bit = Bitsystem zur Basis 32 = 2^32 Zeichen 4294967296 Units
Die einzelnen Bitsysteme und Alphabete sind völlig unabhängig voneinander. Schwierigkeiten bereitet es nur, eigene Symbole für die einzelnen Zeichen (Units) im jeweiligen Bitsystem zu definieren. Im Bitsystem zur Basis 1 sind die Units: "0" und "1" oder historisch: "L" und "H". Das Bitsystem zur Basis 4 kennt die Einheit "nibble" und im Bitsystem zur Basis 16 ist die Einheit: "word". Ab dem Bitsystem zur Basis 9 und höher müssen zwei Zeichen kombiniert oder aber UNICODE verwendet werden.
2. Vergleich mit herkömmlichen Verfahren
Die heute aktuell angewandten Verschlüsselungsverfahren arbeiten fast alle mit Bit Manipulationen im Bitsystem zur Basis 8. Das hat zur Folge, dass der Weg vom Klartextzeichen bis zum Chiffretextzeichen mit einer Funktion in einem einheitlichen Bitsystem gestaltet werden muss. Außerdem wird gefordert, dass Chiffretext und Klartext die gleiche Länge haben. Daraus folgt: Für jeden Klartextbuchstaben gibt es nur ein Chiffretextzeichen, und zwar ein ganz bestimmtes Zeichen im Bitsystem zur Basis 8.
Das CypherMatrix Verfahren dagegen arbeitet mit zwei getrennten Funktionsbereichen (Generator und Codierfunktion). Der Generator stellt die zum Ablauf des Verfahrens erforderlichen Steuerungsparameter bereit und die eigentliche Verschlüsselung vollzieht sich im getrennten Codierbereich. Dabei wird die Verschlüsselung prinzipiell aus der Umwandlung von einem Bitsystem in ein anderes Bitsystem erreicht (Bit-Konversion).
Ein Beispiel für Umwandlungen im CypherMatrix Verfahren: Das Wort "Buddha" wird vom Bitsystem zur Basis 8 in Zeichen des Bitsystems zur Basis 11 umgewandelt:
Alphabet Bitsystem zur Basis 8 (ASCII: 256 Bytes)
Byte$(66) = "B"
Byte$(97) = "a"
Byte$(100) = "d"
Byte$(104) = "h"
Byte$(117) = "u"
....
Index 66 117 100 100 104 97
.... 01000010 01110101 01100100 01100100 01101000 01100001 ....
Bitsystem zu Basis 11
.... 01000010011 10101011001 00011001000 11010000110 0001 ....
Index 531 1369 200 1670
Alphabet Bitsystem zur Basis 11 (2048 Zeichen)
(die Zeichen sind aus zwei ASCII-Zeichen zusammengesetzt)
Alphabet$(200) = "fY"
Alphabet$(531) = "cY"
Alphabet$(1369) = "g#"
Alphabet$(1670) = "hZ"
Chiffretext Basis 11: ...cYg#fYhz....
Die Folge der 8-bit Sequenzen teilt das Verfahren in 11-bit Abschnitte. Die Anzahl der Bits und ihre Reihenfolge bleiben gleich. Kein Bit wird hinzugefügt und kein Bit weggelassen. Die dezimalen Werte im Bitsystem zur Basis 11 sind Indexwerte für die Chiffrezeichen im Chiffrealphabet. Die Umwandlung kann auf alle Bitsysteme von zur Basis 1 bis zur Basis 12 (und höher) angewendet werden.
Die Verschlüsselungen im CypherMatrix Verfahren arbeiten alle wie folgt: Mit der Startsequenz wird die jeweilige CypherMatrix mit 16x16 Zeichen erzeugt, aus der das Chiffrealphabet im angestrebten Bitsystem (Basis 1 bis Basis 12 und höher) herausgezogen wird. Der Klartextblock nach XOR-Verknüpfung im Bitsystem zur Basis 8 wird in Zeichen des festgelegten Bitsystems (Basis 1 bis Basis 12) umgewandelt. Die entstehenden Indizes holen das zugeordnete Chiffrezeichen aus dem Alphabet und verbinden es zum Chiffretext. Die Entschlüsselung geht den umgekehrten Weg.
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. Bei fast allen herkömmlichen Verfahren haben Klartext und Chiffretext die gleiche Länge: Längenkongruenz. Daraus folgt, dass für jedes Klartextzeichen auch ein bestimmtes Chiffrezeichen vorhanden sein muss. Beide Bereiche arbeiten im gleichen Bitsystem zur Basis 8, so dass ein einheitliches Ordnungssystem besteht.
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.
Diese Bedingung ist im CypherMatrix Verfahren nicht erfüllt. Es findet ein Wechsel im Bitsystem statt:
(Umwandlung von Klartext-Zeichen im Bitsystem zur Basis 8 zu Chiffretext-Zeichen im Bitsystem zur
Basis 7), mit der Folge, dass beide Bereiche sich nicht mehr vergleichen lassen.
Durch die Umwandlung der Klartextzeichen vom Bitsystem zur Basis 8 in Chiffrezeichen im Bitsystem zur
Basis 7 entfällt auf jedes Klartextzeichen ein Chiffrezeichen, das um den Faktor 1,143 länger
ist als das verursachende Klartextzeichen. 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. Es fehlt ein
einheitliches Ordnungssystem für beide Bereiche.
Zu den bekanntesten Angriffen auf verschlüsselte Nachrichten gehören Strukturanalyse, "known plaintext attack", "chosen plaintext attack" und "brute force attack", eventuell noch "differenzielle" und "lineare" Kryptoanalyse [#10]. Mit diesen Angriffen sollen aus dem Chiffretext statistisch erfassbare Regelmäßigkeiten herausgefiltert werden, die möglicherweise einen Weg zum Klartext aufzeigen. Die Verfahren setzen jedoch alle voraus, dass Klartext und Chiffretext die gleiche Länge haben. Es soll ja jeder Klartextbuchstabe mit dem zugehörigen Chiffretext-Zeichen in Beziehung gesetzt werden. Infolge der bit-conversion und der dadurch bewirkten Verlängerung des Chiffretextes sind diese Voraussetzungen beim CypherMatrix Verfahren allerdings nicht erfüllt. Es fehlt daher die Basis für alle genannten Angriffszenarien. Sie sind wirkungslos und wir können sie vergessen. Um dies zu testen können Sie sich einige mit CypherMatrix Programmen verschlüsselte Nachrichten "message5.ctx bis message9.ctx" (7.2 MB) als ZIP-Datei auf Ihren Rechner holen und versuchen, die Chiffre mit den heute gängigen Angriffen zu brechen.
Wenn alle herkömmlichen Angriffe wegen der fehlenden Längenkongruenz nicht greifen, bleibt nur noch brute force [#11] mit den folgenden Angriffszenarien:
1. Am Beginn des Verfahrens die "Start Sequenz" suchen,
2. in das laufende Verfahren einsteigen oder
3. vom Ende her den Weg vom Chiffretext zum Klartext finden.
Der Angreifer muss nur in den jeweiligen Situationen alle Ablaufdaten des Programms mit
allen möglichen Daten durchprobieren und das Ergebnis auf Plausibilität prüfen [#12].
Mit der "Start-Sequenz" als General-Schlüssel initialisieren sowohl Sender als auch Empfänger den gesamten Ablauf des Verfahrens. Außer Klartext sind im laufenden Verfahren keine weiteren Eingaben erforderlich, ja auch gar nicht möglich. Die Start-Sequenz umfasst optimal 42 Bytes; sie wird gewöhnlich über die Tastatur eingegeben (ca. 100 Zeichen). Für den Schlüsselraum ergeben sich somit 100^42 = 1E+84 Möglichkeiten. Wenn die Schlüssellänge definiert wird als Exponent (x) zur Basis 2, dessen Potenzierung die Kombination aller Eingabemöglichkeiten ergibt, beträgt die Schlüssellänge in diesem Fall etwa 266 bit (Entropie = 265,75 [#13]). Da jedoch die Länge der Schlüssel gewählt werden kann (zwischen 36 bis 64 Bytes) und grundsätzlich alle 256 ASCII-Zeichen verwendet werden können, ist der Schlüsselraum in Wirklichkeit noch viel größer. Er reicht maximal bis zu 256^64 = 1,34E+154 Kombinationen. Die Schlüssellänge beträgt dann 512 bit (Entropie = 511,99) und die exponentielle Komplexität = O(2^512). Wird für einen Angriffs-Zyklus 1/1000 -stel Sekunde angenommen, beträgt die Zeit bis zu einem Erfolg 3.17E+114 Jahre. Das ist länger als die Zeit, bis sämtliche Materie bei Null Grad Kelvin flüssig wird [#16].
Ein Angreifer kann auch nicht mit Erfolg versuchen, Teile der Start-Sequenz getrennt und nacheinander zu analysieren. Die Schlüssel-Sequenzen müssen in einem Test-Durchgang als Ganzes gefunden werden. Erkenntnisse aus vorhergehenden Durchgängen lassen sich nicht verwerten. Das aber kostet Zeit. Wörterbuch-Angriffe (auf der Basis literarischer oder umgangssprachlicher Zitate) scheiden wegen der Länge der Start-Sequenz (42 Bytes) aus oder lassen sich leicht durch kleine Änderungen vermeiden. Hauptsache, die Passphrase bleibt stets im Gedächtnis, auch ohne aufgeschrieben zu werden.
Die weitere Mölichkeit, einen "Brute-Force-Angriff" zu versuchen, der sog. Geburtstagsangriff
[#12a], kann ebenfalls keinen Erfolg haben. Mit dieser Methode werden allenfalls zwei gleiche Sequenzen
(im Falle einer Kollision) gefunden aber nicht die tatsächlich verwendete Start-Sequenz.
Und nur die benötigt ein Angreifer, um in das Verfahren einbrechen zu können.
b) Einstieg in das laufende Verfahren
Für einen "brute force" Angriff im laufenden Verfahren besteht grundsätzlich kein Einstiegspunkt. Allenfalls könnte versucht werden, einen Matrix-Schlüssel zu rekonstruieren. Der Offset eines "Matrix-Schlüssels" aus der jeweiligen CypherMatrix bestimmt sich aus MODULO 196 +1 des Ergebnisses der expandierten Hash-Funktions-Reihe aus dem vorher gehenden "Matrix-Schlüssel". Also müsste auch der noch gesucht werden, bevor ein "brute force" Angriff gestartet werden könnte. Alle fortlaufenden Matrix-Schlüssel beziehen sich auf 256 mögliche Zeichen. Bei einem Schlüssel von 42 Byte Länge betragen die Möglichkeiten für das Vorkommen eines Zeichens (Schlüsselraum) dann insgesamt 256^42 = 1.4E+101. Das entspricht einer Schlüssellänge von etwa 336 bit (Entropie = 336,00).
Weiterhin könnte versucht werden, die Ausgangsgröße BASIS-VARIATION für die Erzeugung der CypherMatrix (16x16 Zeichen) herauszufinden. Jeder BASIS-VARIATION geht eine Auswahl bestimmter Zeichen (256 ASCII-Zeichen) voraus. Diese Zeichen bilden die Elemente für die CypherMatrix, die aus der BASIS-VARIATION erzeugt wird. Wenn BASIS-VARIATIONen einem "brute force" Angriff ausgesetzt werden sollen, müssen natürlich die Elemente der Matrix und deren Verteilung vor der Generierung der anzugreifenden BASIS-VARIATION bekannt sein. Auswahl der Zeichen und ihre Verteilung werden jeweils bestimmt vom Matrix-Schlüssel aus der vorhergehenden CypherMatrix, deren erste Erzeugung am Anfang des Verfahrens allein durch die Start-Sequenz bestimmt wird. Auswahl und Verteilung der Zeichen sind dem Angreifer aber nicht bekannt. Die sollen ja gerade erst gesucht werden.
So kommen zu den Möglichkeiten der Basis-Variationen noch die Variationen der Matrix-Elemente und deren
Verteilung in der jeweils vorhergehenden Matrix hinzu. Das sind bei 256 Zeichen (Matrix 16x16) insgesamt 256! (Fakultät) = 8.57E+506 Kombinationen.
Insgesamt müsste der Angreifer daher 2.09E+13 x 8.57E+506 = 1.79E+520 Fälle durchprobieren. Das wird ein Angreifer nicht
erleben, auch seine Erben nicht.
c) Vom Ende her kein eindeutiges Ergebnis
Ein "brute force" Angriff vom Ende her kann schon aus folgenden Gründen keinen Erfolg haben:
Dem Angreifer sind grundsätzlich nur der Chiffretext und dessen Länge bekannt. Außerdem kennt er das Verfahren "CypherMatrix" mit seinen drei Funktionen:
Da der Angreifer davon ausgehen muss, dass die Verschlüsselung mit einer Start-Sequenz zwischen 36 bis 64 Bytes eingeleitet worden ist, wird er erst gar nicht versuchen, "brute force" auf den Beginn des Verfahrens anzuwenden (Schlüssellänge = 512 bit). Aussichtsreicher wird es ihm erscheinen, vom vorhandenen Chiffretext auszugehen und den Vorgang vom Ende her aufzurollen.
Als erste Aufgabe müssen somit das Chiffretext-Array mit 128 Zeichen im Bitsystem zus Basis 7
und die Verteilung der Zeichen im Array herausgefunden werden. Die Werte der Chiffrezeichen
(binär oder hex) sind dafür nicht geeignet, da die 7-bit Werte für
eine Rückumwandlung auf die 8-bit Sequenzen der XOR-Verknüpfung (Bitsystem zus Basis 8) nur von den
Positionen der Zeichen im Chiffretext-Array geliefert werden können.
Für 128 Zeichen des Chiffretext-Alphabets ergibt sich ein Kombinationsraum von 128!
(Fakultät) = 2.85E+215 unterschiedlichen Verteilungen. Bei diesem Umfang ist es aussichtslos die richtige Verteilung aus
irgendwelchen Daten ableiten zu wollen. Die richtige Verteilung kann nur durch eine iterative
Auswahl gesucht werden. Ausgangspunkt muss zunächst eine vermutete Struktur des
Arrays sein. Zur Durchführung von "brute force" müssen dann alle anderen möglichen
Verteilungen durchgespielt werden.
Die verschlüsselte Datei >HESSE.CTX< enthält die folgenden Chiffretext-Zeichen:
Characters in the file HESSE.CTX
File contains in total 845 characters,
of these are 203 different characters;
on the average 4 positions per character.
_G$Ԫ!]}r:KhR^l;=[TiqL5)äö2xUßyn
~*cj03¬-+Z#Wf@FB.OQp.97(D
%v'SN8&bϷsC`{YA\IkٟJzt?.odM meH6
ɍu/1PgV|4
5F CA 47 CB 24 91 D4 AA F1 EA 21 BD F6 C5 5D 7D 72 A7 3A 4B
68 EE 52 5E 6C 8A 3B A3 3D 5B 54 9C 83 B5 D5 69 71 4C 35 A5
AD 29 84 94 90 BB 32 78 85 55 8F 9B E1 B6 E5 79 B3 6E B9 C6
8E 7E 2A 63 B4 6A 30 ED D2 33 C2 AC 88 2D AB 89 2B 5A 97 95
23 E7 FA 8B 8C F2 57 A4 66 82 E2 40 C0 86 D1 C1 46 D7 42 3E
4F E3 EB 51 F4 FD EC F5 BA F8 70 2E E6 39 37 E8 93 CD 28 44
25 76 27 E4 D0 53 CE 4E 38 FB F9 C7 FC 26 62 CF B7 98 73 43
60 7B 59 BC 41 9D AE 5C D8 D3 49 6B D9 9F 4A DA 7A A1 BE 74
9E 3F 3C 6F 64 A6 7F 92 EF A2 C3 4D 99 96 1F D6 6D 65 48 36
AF E0 C9 8D 75 2F BF 31 A9 A8 50 B8 87 67 56 FE 7C E9 C8 F3
C4 34 CC
Hinweis: Die Ermittlung der Chiffretext-Zeichen erfolgte mit der Analyse-Funktion des Programms
>CypherXT.exe<.
Als Ausgangspunkt wird folgendes Chiffretext-Alphabet freihändig gewählt:
Gewähltes >Chiffretext-Alphabet< (ASCII)
Index 1 - 16: _ G $ ! ] }
Index 17 - 32: r : K h R { l X = [ T
Index 33 - 48: q L 5 ) ä ö 2 x
Index 49 - 64: U a { y n c
Index 65 - 80: j 0 6 - Z
Index 81 - 96: # W f @
Index 97 - 112: F B > O Q 8 < p
Index 113 - 128: 9 7 ( D v S N
Gewähltes >Chiffretext-Alphabet< (hex)
5F CA 47 CB 24 91 D4 AA F1 EA 21 BD F6 C5 5D 7D
72 A7 3A 4B 68 EE 52 7B 6C 8A 58 A3 3D 5B 54 9C
83 B5 D5 E3 71 4C 35 A5 AD 29 84 94 90 BB 32 78
85 55 61 9B D8 B6 E5 79 B3 6E B9 C6 8E C1 2A 63
B4 6A 30 FC D2 36 C2 AC 88 2D FB 89 A6 5A 97 95
23 E7 F0 8B 8C F2 57 A4 66 82 E2 40 C0 86 D1 C1
46 D7 42 3E 4F E3 EB 51 F4 38 CF F5 C7 3C 70 C4
E6 39 37 E8 93 CD 28 44 FA 76 D2 E4 D0 53 CE 4E
Die einzelnen Zeichen des Chiffretextes
