Grundlage der Analyse bildet die Chiffrier- bzw. Dechif-
frierfunktion des Pascal-Source-Codes TC850.pas.
Festlegungen:
Strukturschlüssel: 1101011010111111
1010010011110111
0011000000111110
0100001100001010
0011010001001110
1101011100110001
1100101111101010
1110011100001000
Grundschlüssel: "GYFXFMBFJXIDFKMN"
Spruchschlüssel: "WWWNN NOOOL LLRRR KKKAA APPPS SSBBB"
Grund- und Spruchschlüssel Kodierung
Grund- Spruchschlüssel | "ITA 2" XOR SHL 3 | für die MATRIX |
Bu | Zi | ITA-2 | SHL 3 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | gebildetes Element |
A | - | 0x14 | 0xa0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0xb4 |
B | ? | 0x13 | 0x98 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 0x8b |
C | : | 0x0e | 0x70 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 1 | 0x7e |
D | @ | 0x12 | 0x90 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 0 | 0x82 |
E | 3 | 0x10 | 0x80 | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 0x90 |
F | @ | 0x16 | 0xb0 | 0 | 1 | 0 | 1 | 0 | 1 | 0 | 0 | 0xa6 |
G | @ | 0x0b | 0x58 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | 0x53 |
H | @ | 0x05 | 0x28 | 0 | 0 | 1 | 1 | 0 | 1 | 0 | 1 | 0x2d |
I | 8 | 0x0c | 0x60 | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0x6c |
J | @ | 0x1a | 0xd0 | 0 | 1 | 1 | 0 | 0 | 1 | 0 | 0 | 0xca |
K | ( | 0x1e | 0xf0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | 0xee |
L | ) | 0x09 | 0x48 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0x41 |
M | . | 0x07 | 0x38 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0x3f |
N | , | 0x06 | 0x30 | 1 | 1 | 0 | 1 | 1 | 0 | 1 | 0 | 0x36 |
O | 9 | 0x03 | 0x18 | 1 | 1 | 0 | 0 | 0 | 1 | 0 | 1 | 0x1b |
P | 0 | 0x0d | 0x68 | 1 | 1 | 0 | 1 | 0 | 0 | 1 | 0 | 0x65 |
Q | 1 | 0x1d | 0xe8 | 1 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0xf5 |
R | 4 | 0x0a | 0x50 | 0 | 1 | 0 | 1 | 0 | 0 | 1 | 1 | 0x5a |
S | ' | 0x14 | 0xa0 | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 1 | 0xb4 |
T | 5 | 0x01 | 0x08 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 0x09 |
U | 7 | 0x1c | 0xe0 | 0 | 0 | 1 | 1 | 0 | 0 | 1 | 0 | 0xfc |
V | = | 0x0f | 0x78 | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 0 | 0x77 |
W | 2 | 0x19 | 0xc8 | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 1 | 0xd1 |
X | / | 0x17 | 0xb8 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | 0xaf |
Y | 6 | 0x15 | 0xa8 | 1 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0xbd |
Z | + | 0x11 | 0x88 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0x99 |
Reg III | 0x00 | 0x00 | 1 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 0x00 |
wr | 0x02 | 0x10 | 0 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | 0x12 |
Spc | 0x04 | 0x20 | 1 | 0 | 0 | 1 | 0 | 1 | 0 | 1 | 0x24 |
zv | 0x08 | 0x40 | 0 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0x48 |
Reg II | 0x1b | 0xd8 | 0 | 1 | 1 | 0 | 1 | 0 | 1 | 0 | 0xc3 |
Reg I | 0x1f | 0xf8 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0xe7 |
Tabelle: Substitution für die Grund- und Spruchschlüssel |
Aus dem Grundschlüssel (MatrixB) wird
aus 16 Zeichen:
"GYFXFMBFJXIDFKMN"
die 10 kodierte Bytes:
"0xf5, 0x99, 0xa6, 0xaf, 0xa6, 0x3f, 0x8b, 0xa6, 0xca, 0xaf"
Die unterstrichenen Werte werden nicht genutzt!
Der Grundschlüssel wird verlängert mit den Bytes 2 … 7 des
Grundschlüssels, in die 16 kodierten Bytes:
"0xf5, 0x99, 0xa6, 0xaf, 0xa6, 0x3f, 0x8b, 0xa6,
0xca, 0xaf, 0xa6, 0xaf, 0xa6, 0x3f, 0x8b, 0xa6"
Aus dem Spruchschlüssel (MatrixD) wird aus den 30 Buchstaben:
"WWWNN NOOOL LLRRR KKKAA APPPS SSBBB"
zuerst 10 Buchstaben extrahiert:
"WNOLRKAPSB"
dann in 10 kodierte Bytes:
"0xd1, 0x36, 0x1b, 0x41, 0x5a, 0xee, 0xb4, 0x65, 0xb4, 0x8b"
Der Spruchschlüssel (MatrixD) wird verlängert mit den Bytes
1 … 6 des Spruchschlüssels, in die 16 kodierte Bytes:
"0xd1, 0x36, 0x1b, 0x41, 0x5a, 0xee, 0xb4, 0x65,
0xb4, 0x8b, 0x36, 0x1b, 0x41, 0x5a, 0xee, 0xb4"
Aus den Matrizzen MatrixB und MatrixD wird ein neues Feld gebildet
die die Dimension von 31 bytes hat, Regist[31], entsprechend folgendem
Algorithmus:
Regist[1] ist markiert mit 0xff.
Regist[x+1] = MatrixD[x] xor MatrixB[x]
wobei x im Wertebereich von 1 bis 10 liegt.
Folgend der Wertebreich von 11 bis 16,
Regist[x+1] = MatrixD[1:6] xor MatrixB[x].
Folgend der Wertebreich von 17 bis 20,
Regist[x+1] = MatrixD[7:10] xor MatrixB[1:4].
Folgend der Wertebreich von 21 bis 26,
Regist[x+1] = MatrixD[1:6] xor MatrixB[5:10].
Folgend der Wertebreich von 27 bis 30,
Regist[x+1] = MatrixD[7:10] xor MatrixB[2:5].
In die Matrizze MatrixP[8,16] wird transformiert:
MatrixP[0:7,0:15] = Strukturschlüssel_bit0[] xor MatrixD[] xor MatrixB[]
Von den gebildeten 128 bit muß die Anzahl der "1" größer 33 und
kleiner 95 sein. Ist das nicht der Fall, wird der Struktur-
schlüssel[0:7, 0:14] geladen mit Strukturschlüssel[0:7, 1:15]
und die vorherige Funktion wiederholt.
Im ungünstigsten Fall wird das letzte Bit des Strukturschlüssel,
"0 oder 1", solange mit "0" oder "1" gefüllt bis
die Bedingung erfüllt ist!
Hier ist ersichtlich welche Qualität der Strukturschlüssel
haben muß um nicht in den o.g. Zustand zu kommen.
Hier liegt die "0/1" Verteilung bei min. 26% und max. 74%.
Für eine gute Gleichverteilung sollten diese min. 45% und max. 55% haben.
Im weiteren wird die Parität der gebildeten "1" der MatrixP ermittelt.
Ist das Ergebnis eine gerade Parität, wird das erste Bit der
MatrixP[0,0] XOR "1" verknüpft.
Somit ist die Parität immer ungerade.
Normalerweise sind jetzt alle Vorbereitungen getroffen worden
für das Chiffrieren bzw. Dechiffrieren. Nun wird aber der
Spruchschlüssel als Schlüsselelement des Algorithmus verwendet
und stellt keinen Initialisierungsvektor (IV) im herkömmlichen
Sinn dar. Dies wird jetzt durch eine Funktion mit einem festen
Vektor realisiert. Im Programm als VORLAUF benannt, führt
150 Runden als IV durch.
Die Matrizze REGIST[], aus MatrixD und MatrixB erzeugt, wird
über eine feste Matrix
MASKE: $14,$73,$A3,$33,$8F,$25,$67,$BD,$16,$B6,$B4,$4C,$0C,$B4,$51,
$90,$6B,$1A,$6B,$09,$E0,$59,$0D,$A8,$18,$E1,$70,$61,$C1,$01,$81
durch die Anwendung der AND-Funktion die festgelegten Bits,
definiert durch die Maske, extrahiert. Andere Bits werden ver-
worfen. Danach mit dem vorherigen extrahierten Wert XOR verküpft.
Die Matrizze REGIST wird mit dem neuen Wert geladen und um eine
Position in der Matrix verschoben. Der letzte berechnet Wert,
einer Runde, wird im Byte C gespeichert. Aus C wird noch ein
Paritätsbit ZT gebildet. Bei einer ungeraden Anzahl von "1"
ist das Paritätsbit ZT = 1.
Auffällig ist, daß die Funktion RegSatzVer, bis auf die Parameter,
identisch ist mit der Funktion in der PX-1000NSA
Die Parameter im Vergleich:
| PX1000NSA | TC-850 |
Runden: | 16 | 31 |
Feld: | 16 byte | 31 byte |
Maske: | 4 bit | 8 bit |
Ausgabe: | 1 byte | 1 byte |
Tabelle: Parameter der Rekursionsfunktion |
In Bruce Schneider, Applied Cryptography
bzw. Angewande Kryplogie
wird auf das NSA Patent US 5.237.615 verwiesen. Bereits 1963 wurde im
US Patent US 3.364.308 sowie weiteren Patenten so verfahren.
Nun sind für die Bildung der Additionsreihen folgende Matrizzen
und Bytes erzeugt worden:
ZT (1 byte) aus zt = zt XOR Summe vek[1:8]
C [8 Bit] aus c[] = Rekursion XOR REGIST[1:31] AND MASKE[1:31]
REGIST[31 byte] aus MtxB[1:16, 1:8] und MtxD[1:16, 1:8]
MtxP [128 byte] aus MtxP[0:7,0:31] XOR MtxD[1:16,8:1] XOR MtxB[1:16,8:1]
MtxB [128 byte] aus Grundschlüssel
MtxD [128 byte] aus Spruchschlüssel
Die Variablen bzw. Felder C, ZT und REGIST unterliegen während
der Chiffrierung bzw. Dechiffrierung permanenter Änderung.
Zur De- bzw. Chiffrierung werden die Zeichen:
Reg I … III, WR, ZV, Leerzeichen in einem Bigramm mit einem
führenden "Y" umgewandelt.
Register I … III = Register 32., Bu, Zi.
Klartext | Substitut | Dechiff. |
Y | YS | Y |
WR | YO | Wr |
ZV | YL | Zv |
Bu | YK | Bu |
Zi | YJ | Zi |
' ' | YH | ' ' |
32. | YT | | |
Die Symbole in Dechiff. werden als Zeichen bzw. Steuerzeichen umgesetzt. |
Im folgenden wird der Klar- bzw. Geheimtext chiffriert.
GTX = Klartext XOR Additionsreihe
Klartext = GTX XOR Additionsreihe
Bei der Chiffrierung und Dechiffrierung wird bei dem Einsatz der
Bigramme, trotzdem die Additionsreihe weitergebildet aber das
nächste Element wird nicht verwendet.
Ein Beispiel:
Der Klartext lautet: YPS
Erstes chiffriertes Element:
GTX[1] = KTxt[1] XOR Add[1] = 0x15
Nächstes gebildetes Additionselement bleibt ungenutzt.
Zweites chiffrierte Element.
GTX[2] = KTxt[2] XOR Add[3] = 0x01
Der Geheimtext sieht entsprechend aus: YSE.
Drittes chiffrierte Element.
GTX[2] = KTxt[3] XOR Add[4] = 0x01
Der Geheimtext sieht entsprechend aus: YSEE.
Beim Dechiffrieren wird ebenfalls so gearbeitet:
Erstes chiffriertes Element:
KTxt[1] = GTX[2] XOR Add[1] = 0x14
Nächstes gebildetes Additionselement bleibt ungenutzt.
Zweites chiffrierte Element.
KTxt[2] = GTX[3] XOR Add[3] = 0x0d
Im Klartext sieht das entsprechend aus: YP.
Zweites chiffrierte Element.
KTxt[3] = GTX[4] XOR Add[4] = 0x05
Im Klartext sieht das entsprechend aus: YPS.
Ein Schelm wer da Böses denkt, aber abwegig ist es nicht.
Es wird ein auftretender Zyklus, Wiederholung der Folgen, verschleiert.
Denn wozu muß die Additionsreihe synchron sein?
Dazu findet man auch einen guten Hinweis in der Literatur
bei Res Strehle: Operation Crypto und Verschlüsselt.
Beschrieben wird dort wie ein Verkaufsingenieur der Crypto-AG den
jugoslawischen Offizieren erklären soll warum ständig der aktuelle
Stand des Schlüssels übertragen wird.
In den Chiffrierverfahren ARGON und DUDEK wird bei der
Nutzung des Kodeumsetzer die Umwandlung der chiffrierten
Zeichen in Bigramme durchgeführt. Aber im Gegensatz zum
oben genannter Vorgehensweise wird das nächste zu chiffrierende
Zeichen auch mit dem nächsten Element der Additionsreihe
chiffriert. Bei der Dechiffrierung erfolgt die Umsetzung
des Bigramm in das entsprechenden Zeichen und wird dann
dechiffriert.
Die Bildung der Additionsreihen erfolgt durch folgende Schritte:
In einer Schleife mit 5 Runden.
Bei einer geplanten ASCII Chiffrierung, sind 7 Runden notwendig.
- Rekursionsregister:
· 31 Runden, Bearbeitung MtxP
· Extrahieren eines Bytes "C",
- Gamma( Gam, MtxP, C, ZT):
· Spaltentransposition Pij, aus MtxP[] und C
· Gam = Pij XOR C[8] XOR ZT
- Add << 1
- Add = Add XOR Gam
- ELMZT(ZT,C)
· ZT = Parität C
- Ausgabe maskiert auf 0x1f, ITA-2 Zeichen.
Schluß endlich wird der Klar- bzw. Geheimtext mit dem gebil-
deten Additionsreihe XOR verknüpft.
Dabei wird die Substitution der Steuerzeichen und des "Y"
berücksichtigt sowie wie oben bereits beschrieben ein "Leertakt eingefügt"!
Offen ist noch eine Analyse der Variable C - der Additionsreihe!
Welche Programmabschnitte sehe ich als Kritisch an:
- die Verkürzung des Spruchschlüssels mit anschließender
- Verlängerung des Grund- und Spruchschlüssel, die ein
Zyklus darstellt;
- die Substitution des 5 Bit ITA-2 in die 8bit Kodierung;
- die Bildung von C mittels der Kaskadenverknüpfung;
- die Maske in der Kaskadenverknüfung;
- die Beibehaltung der Matrix P, die sich während der
Chiffrierung nicht verändert;
- das Einfügen eines Leerschrittes bei der "Y"
Substitution.
Experimentell wurde die Maske für die Kaskadenverknüpfung
ersetzt durch die dynamischen Werte aus dem Feld REGIST,
das in der Kaskadenverknüpfung ständiger Veränderung
unterliegt. Das Ergebnis waren bessere Zufallswerte.
In der Software zur Ermittlung von Klartexten und Schlüsseln
aus der Verknüpfung von mehreren Geheimtexten sind ein Beleg
dafür das viele schlüsselgleiche Sprüche erzeugt werden.
Die nur aus der Betrachtung des Geheimtextes erst mal nicht
sofort erkennbar sind.
Genannt sei dabei Zyklus, Redundanz und in Teilen identische
Geheimtexte als Kriterium für die Dekryptierbarkeit.