Advanced Encryption Standard Rijndael

Advanced Encryption Standard 

Rijndael 

Wolfgang Gummlich 

18. Januar 2007

Inhalt 

1 Einführung 

2 Spezifikation von Rijndael 

3 Kryptoanalyse

Wie Rijndael zu AES wurde.. 

Frühere Standard DES wegen des zu kurzen Schlüssels nicht 

mehr sicher gegen Brute-Force-Angriffe und 3DES zu langsam



mehr sicher gegen Brute-Force-Angriffe und 3DES zu langsam 

September 1997: National Institute of Standards and 

Technology (NIST) startete Aufruf für Nachfolger von DES





Technology (NIST) startete Aufruf für Nachfolger von DES 

August 1998: 15 Kandidaten vorgestellt






August 1998: 15 Kandidaten vorgestellt 

August 1999: NIST verkündete 5 Finalisten: MARS, RC6, 

Rijndael, Serpent, Twofish








Rijndael, Serpent, Twofish 

02. Oktober 2000: NIST ernannte Rijndael zum Advanced 

Encryption Standard








Rijndael, Serpent, Twofish 

02. Oktober 2000: NIST ernannte Rijndael zum Advanced 

Encryption Standard 

benannt nach seinen Erfindern V. Rijmen und J. Daemen

Designkriterien 

Sicherheit gegen alle bekannten Angriffe


Sicherheit gegen alle bekannten Angriffe 

hohe Geschwindigkeit und geringer Speicherverbrauch auf 

vielen gängigen Plattformen




vielen gängigen Plattformen 

einfache Spezifikation




vielen gängigen Plattformen 

einfache Spezifikation 

einfache Implementierung

Mathematische Grundlagen 

Repräsentationsmöglichkeiten eines Bytes: 

binär: b 7 b 6 b 5 b 4 b 3 b 2 b 1 b 0 mit b i ∈ GF (2) = {0, 1}



binär: b 7 b 6 b 5 b 4 b 3 b 2 b 1 b 0 mit b i ∈ GF (2) = {0, 1} 

hexadezimal: H 1 H 0 mit H i ∈ {0, . . . , F}




hexadezimal: H 1 H 0 mit H i ∈ {0, . . . , F} 

Polynom: b(x) = ∑ 7 

i=0 b ix i mit b(x) ∈ GF (2)[x]/m(x)




hexadezimal: H 1 H 0 mit H i ∈ {0, . . . , F} 

Polynom: b(x) = ∑ 7 

i=0 b ix i mit b(x) ∈ GF (2)[x]/m(x) 

Bsp.: 01010111 = 57 = x 6 + x 4 + x 2 + x + 1


Addition von Bytes: 

c(x) = a(x) + b(x) ⇔ c i = a i ⊕ b i


Addition von Bytes: 

c(x) = a(x) + b(x) ⇔ c i = a i ⊕ b i 

〈BYTES, ⊕〉 ist eine abelsche Gruppe


Multiplikation von Bytes: 

c(x) ≡ a(x) · b(x) 

mod m(x) = a(x) ⊗ b(x) 

mit m(x) = x 8 + x 4 + x 3 + x + 1 = 11B



c(x) ≡ a(x) · b(x) 

mod m(x) = a(x) ⊗ b(x) 

mit m(x) = x 8 + x 4 + x 3 + x + 1 = 11B 

m(x) ist das erste Polynom einer 1986 von Lidl und Niereiter 

publizierten Liste von irreduziblen Polynomen vom Grad 8.



c(x) ≡ a(x) · b(x) 

mod m(x) = a(x) ⊗ b(x) 

mit m(x) = x 8 + x 4 + x 3 + x + 1 = 11B 

m(x) ist das erste Polynom einer 1986 von Lidl und Niereiter 

publizierten Liste von irreduziblen Polynomen vom Grad 8. 

〈BYTES, ⊗〉 ist eine abelsche Gruppe


Folgerung 

Die 256 möglichen Byte-Werte mit der XOR-Addition und der 

Multiplikation modulo m(x) bilden den Körper GF (2 8 ).


Ein 32-Bit-Wort (4-Byte-Array) kann als Polynom über 

GF (2 8 ) vom Grad ≤ 3 betrachtet werden.



GF (2 8 ) vom Grad ≤ 3 betrachtet werden. 

Die Addition erfolgt, wie gewohnt, komponentenweise mittels 

XOR.



GF (2 8 ) vom Grad ≤ 3 betrachtet werden. 

Die Addition erfolgt, wie gewohnt, komponentenweise mittels 

XOR. 

Bei der Multiplikation wird das (reduzible) 

Reduktionspolynom x 4 + 1 verwendet.


c(x) = a(x) · b(x) 

c 6 x 6 + c 5 x 5 + c 4 x 4 + c 3 x 3 + c 2 x 2 + c 1 x + c 0 = 

(a 3 x 3 + a 2 x 2 + a 1 x + a 0 ) · (b 3 x 3 + b 2 x 2 + b 1 x + b 0 ) 

c 0 = a 0 ⊗ b 0 c 4 = a 3 ⊗ b 1 ⊕ a 2 ⊗ b 2 ⊕ a 1 ⊗ b 3 

c 1 = a 1 ⊗ b 0 ⊕ a 0 ⊗ b 1 c 5 = a 3 ⊗ b 2 ⊕ a 2 ⊗ b 3 

c 2 = a 2 ⊗ b 0 ⊕ a 1 ⊗ b 1 ⊕ a 0 ⊗ b 2 c 6 = a 3 ⊗ b 3 

c 3 = a 3 ⊗ b 0 ⊕ a 2 ⊗ b 1 ⊕ a 1 ⊗ b 2 ⊕ a 0 ⊗ b 3


c 0 = a 0 ⊗ b 0 c 4 = a 3 ⊗ b 1 ⊕ a 2 ⊗ b 2 ⊕ a 1 ⊗ b 3 

c 1 = a 1 ⊗ b 0 ⊕ a 0 ⊗ b 1 c 5 = a 3 ⊗ b 2 ⊕ a 2 ⊗ b 3 

c 2 = a 2 ⊗ b 0 ⊕ a 1 ⊗ b 1 ⊕ a 0 ⊗ b 2 c 6 = a 3 ⊗ b 3 

c 3 = a 3 ⊗ b 0 ⊕ a 2 ⊗ b 1 ⊕ a 1 ⊗ b 2 ⊕ a 0 ⊗ b 3 

Da x j mod (x 4 + 1) ≡ x j mod 4 ergibt sich für d(x) ≡ a(x) · b(x) 

mod (x 4 + 1) = d 3 x 3 + d 2 x 2 + d 1 x + d 0 : 

d 0 = c 0 ⊕ c 4 = (a 0 ⊗ b 0 ) ⊕ (a 3 ⊗ b 1 ) ⊕ (a 2 ⊗ b 2 ) ⊕ (a 1 ⊗ b 3 ) 

d 1 = c 1 ⊕ c 5 = (a 1 ⊗ b 0 ) ⊕ (a 0 ⊗ b 1 ) ⊕ (a 3 ⊗ b 2 ) ⊕ (a 2 ⊗ b 3 ) 

d 2 = c 2 ⊕ c 6 = (a 2 ⊗ b 0 ) ⊕ (a 1 ⊗ b 1 ) ⊕ (a 0 ⊗ b 2 ) ⊕ (a 3 ⊗ b 3 ) 

d 3 = cc 3 ⊕c 3 = (a 3 ⊗ b 0 ) ⊕ (a 2 ⊗ b 1 ) ⊕ (a 1 ⊗ b 2 ) ⊕ (a 0 ⊗ b 3 )


d 0 = c 0 ⊕ c 4 = (a 0 ⊗ b 0 ) ⊕ (a 3 ⊗ b 1 ) ⊕ (a 2 ⊗ b 2 ) ⊕ (a 1 ⊗ b 3 ) 

d 1 = c 1 ⊕ c 5 = (a 1 ⊗ b 0 ) ⊕ (a 0 ⊗ b 1 ) ⊕ (a 3 ⊗ b 2 ) ⊕ (a 2 ⊗ b 3 ) 

d 2 = c 2 ⊕ c 6 = (a 2 ⊗ b 0 ) ⊕ (a 1 ⊗ b 1 ) ⊕ (a 0 ⊗ b 2 ) ⊕ (a 3 ⊗ b 3 ) 

d 3 = cc 3 ⊕c 3 = (a 3 ⊗ b 0 ) ⊕ (a 2 ⊗ b 1 ) ⊕ (a 1 ⊗ b 2 ) ⊕ (a 0 ⊗ b 3 ) 

Multiplikation zweier 4-Byte-Arrays mod (x 4 + 1) als 

Matrix-Vektor-Multiplikation: 

⎛ ⎞ ⎛ 

⎞ ⎛ ⎞ 

d 0 a 0 a 3 a 2 a 1 b 0 

⎜d 1 

⎟ 

⎝d 2 

⎠ = ⎜a 1 a 0 a 3 a 2 

⎟ 

⎝a 2 a 1 a 0 a 3 

⎠ × ⎜b 1 

⎟ 

⎝b 2 

⎠ 

d 3 a 3 a 2 a 1 a 0 b 3

Blockchiffren 

Eine Blockchiffre ist eine Transformation eines 

n-Bit-Klartextes zu einem n-Bit-Chiffretext unter Einfluss 

eines Schlüssels k.

Blockchiffren 

Eine Blockchiffre ist eine Transformation eines 

n-Bit-Klartextes zu einem n-Bit-Chiffretext unter Einfluss 

eines Schlüssels k. 

Eine iterierte Blockchiffre ist eine Blockchiffre, bei der die 

Transformation mehrmals hintereinander ausgeführt wird. Eine 

Ausführung dieser Transformation wird Runde genannt. In 

jeder Runde wird ein eigener Rundenschlüssel verwendet, der 

vorher berechnet wird.

Blockchiffren 

Eine schlüsselalternierende Blockchiffre ist eine Blockchiffre 

mit folgenden beiden Eigenschaften:

Blockchiffren 


mit folgenden beiden Eigenschaften: 

Es werden abwechselnd Rundentransformationen und 

Schlüsseladditionen ausgeführt. Der erste Rundenschlüssel wird 

vor der ersten Runde und der letzte Rundenschlüssel nach der 

letzten Runde addiert.

Blockchiffren 






letzten Runde addiert. 

Einfache Schlüsseladdition mittels XOR.

Blockchiffren 







Einfache Schlüsseladdition mittels XOR. 

Eine schlüssel-iterierte Blockchiffre ist eine 

schlüsselalternierende Blockchiffre, wobei jede Runde (bis auf 

vielleicht die erste oder letzte Runde) gleich ist.

Blockchiffren 







Einfache Schlüsseladdition mittels XOR. 

Eine schlüssel-iterierte Blockchiffre ist eine 

schlüsselalternierende Blockchiffre, wobei jede Runde (bis auf 

vielleicht die erste oder letzte Runde) gleich ist. 

Rijndael ist eine schlüssel-iterierte Blockchiffre.

Verschlüsselungsmodi 

Die zu verschlüsselnde Nachricht wird in Blöcke gleicher 

Länge unterteilt.



Länge unterteilt. 

ECB (Electronic Code Book Mode): Die Chiffre wird auf 

jedem Block unabhängig voneinander audgeführt.





jedem Block unabhängig voneinander audgeführt. 

Nachteil: Wenn die Nachricht zwei identische Blöcke enthält, 

sind die zugehörigen Cryptogramme ebenfalls gleich.







sind die zugehörigen Cryptogramme ebenfalls gleich. 

CBC (Cipher Block Chaining Mode): Bevor ein Block 

verschlüsselt wird, wird er mit dem Cryptogramm des 

vorherigen Blockes XOR-verknüpft.







sind die zugehörigen Cryptogramme ebenfalls gleich. 

CBC (Cipher Block Chaining Mode): Bevor ein Block 

verschlüsselt wird, wird er mit dem Cryptogramm des 

vorherigen Blockes XOR-verknüpft. 

Wenn die Länge der Nachricht kein ganzzahliges Vielfaches 

der Blocklänge ist, muss die Nachricht aufgefüllt werden bis 

die gewünschte Länge erreicht ist. Dadurch wird das 

Cryptogramm länger als die Nachricht, was in einigen Fällen 

ein Nachteil sein kann.

Inhalt 

1 Einführung 


3 Kryptoanalyse

AES - Parameter 

Block-/Schlüssellängen: 128, 160, 192, 224, 256 bit


Block-/Schlüssellängen: 128, 160, 192, 224, 256 bit 

N b = Blocklänge 

32




32 

N k = Schlüssellänge 

32




32 


32 

N r = max{N b , N r } + 6




32 


32 

N r = max{N b , N r } + 6 

N b = 4 N b = 5 N b = 6 N b = 7 N b = 8 

N k = 4 10 11 12 13 14 

N k = 5 11 11 12 13 14 

N k = 6 12 12 12 13 14 

N k = 7 13 13 13 13 14 

N k = 8 14 14 14 14 14

Der Zustand 

Die Objekte, auf denen Rijndael arbeitet, sind 4 × N b -Arrays 

(4 × 4 bei AES), dessen Elemente Bytes sind.

Der Zustand 

Die Objekte, auf denen Rijndael arbeitet, sind 4 × N b -Arrays 

(4 × 4 bei AES), dessen Elemente Bytes sind. 

s 0,0 s 0,1 s 0,2 s 0,3 

s 1,0 s 1,1 s 1,2 s 1,3 

s 2,0 s 2,1 s 2,2 s 2,3 

s 3,0 s 3,1 s 3,2 s 3,3 

mit s i,j ∈ GF (2 8 ).

Ein- und Ausgabe 

Sei t 0 t 1 . . . t 15 der Eingabetext und k 0 k 1 . . . k 23 der Schlüssel.


Sei t 0 t 1 . . . t 15 der Eingabetext und k 0 k 1 . . . k 23 der Schlüssel. 

t 0 t 4 t 8 t 12 

k 0 k 4 k 8 k 12 k 16 k 20 

t 3 t 7 t 11 t 15 k 3 k 7 k 11 k 15 k 19 k 23 

t 1 t 5 t 9 t 13 

k 1 k 5 k 9 k 13 k 17 k 21 

t 2 t 6 t 10 t 14 

k 2 k 6 k 10 k 14 k 18 k 22


Sei t 0 t 1 . . . t 15 der Eingabetext und k 0 k 1 . . . k 23 der Schlüssel. 

t 0 t 4 t 8 t 12 

k 0 k 4 k 8 k 12 k 16 k 20 

t 3 t 7 t 11 t 15 k 3 k 7 k 11 k 15 k 19 k 23 

t 1 t 5 t 9 t 13 

k 1 k 5 k 9 k 13 k 17 k 21 

t 2 t 6 t 10 t 14 

k 2 k 6 k 10 k 14 k 18 k 22 

Eingabe: a i,j = t i+4j , 0 ≤ i < 4, 0 ≤ j < N b 

Ausgabe: t i = a i mod 4,⌊i/4⌋ , 0 ≤ i < 4 · N b

Der Algorithmus 


{ 

KeyExpansion(CipherKey, RoundKey); 

AddRoundKey(State, RoundKey[0]); 

for i = 1 to Nr-1 do Round(State, RoundKey[i]); 

FinalRound(State, RoundKey[Nr]); 

}

Der Algorithmus 


{ 


AddRoundKey(State, RoundKey[0]); 

for i = 1 to Nr-1 do Round(State, RoundKey[i]); 

FinalRound(State, RoundKey[Nr]); 

} 

InvRijndael 

{ 


InvFinalRound(State, RoundKey[Nr]); 

for i = 1 to Nr-1 do InvRound(State, RoundKey[i]); 

InvAddRoundKey(State, RoundKey[0]); 

}

Die Runden 

Round(State, RoundKey[i]) 

{ 

SubBytes(State); 

ShiftRows(State); 

MixColumns(State); 

AddRoundKey(State, RoundKey[i]); 

}

Die Runden 

Round(State, RoundKey[i]) 

{ 



MixColumns(State); 

AddRoundKey(State, RoundKey[i]); 

} 

FinalRound(State, RoundKey[Nr]) 

{ 



AddRoundKey(State, RoundKey[Nr]); 

}

Die Runden 

InvRound(State, RoundKey[i]) 

{ 

InvAddRoundKey(State, RoundKey[i]); 

InvMixColumns(State); 

InvShiftRows(State); 

InvSubBytes(State); 

} 

InvFinalRound(State, RoundKey[0]) 

{ 

InvAddRoundKey(State, RoundKey[0]); 

InvShiftRows(State); 

InvSubBytes(State); 

}

SubBytes

S-Box 

S-Box 0 1 2 3 4 5 6 7 8 9 A B C D E F 

0 63 7C 77 7B F2 6B 6F C5 30 01 67 2B FE D7 AB 76 

1 CA 82 C9 7D FA 59 47 F0 AD D4 A2 AF 9C A4 72 C0 

2 B7 FD 93 26 36 3F F7 CC 34 A5 E5 F1 71 D8 31 15 

3 04 C7 23 C3 18 96 05 9A 07 12 80 E2 EB 27 B2 75 

4 09 83 2C 1A 1B 6E 5A A0 52 3B D6 B3 29 E3 2F 84 

5 53 D1 00 ED 20 FC B1 5B 6A CB BE 39 4A 4C 58 CF 

6 D0 EF AA FB 43 4D 33 85 45 F9 02 7F 50 3C 9F A8 

7 51 A3 40 8F 92 9D 38 F5 BC B6 DA 21 10 FF F3 D2 

8 CD 0C 13 EC 5F 97 44 17 C4 A7 7E 3D 64 5D 19 73 

9 60 81 4F DC 22 2A 90 88 46 EE B8 14 DE 5E 0B DB 

A E0 32 3A 0A 49 06 24 5C C2 D3 AC 62 91 95 E4 79 

B E7 C8 37 6D 8D D5 4E A9 6C 56 F4 EA 65 7A AE 08 

C BA 78 25 2E 1C A6 B4 C6 E8 DD 74 1F 4B BD 8B 8A 

D 70 3E B5 66 48 03 F6 0E 61 35 57 B9 86 C1 1D 9E 

E E1 F8 98 11 69 D9 8E 94 9B 1E 87 E9 CE 55 28 DF 

F 8C A1 89 0D BF E6 42 68 41 99 2D 0F B0 54 BB 16

SubBytes 

SBox(x) = f (g(x)) mit

SubBytes 

SBox(x) = f (g(x)) mit 

{ x 

g(x) = 

−1 in GF (2 8 ) , x ≠ 0 

0 , x = 0

SubBytes 

SBox(x) = f (g(x)) mit 

{ x 

g(x) = 

−1 in GF (2 8 ) , x ≠ 0 

0 , x = 0 

⎛ 

⎞ ⎛ ⎞ ⎛ ⎞ 

1 1 1 1 1 0 0 0 a 7 0 

0 1 1 1 1 1 0 0 

a 6 

1 

0 0 1 1 1 1 1 0 

a 5 

1 

f (a) = 

0 0 0 1 1 1 1 1 

1 0 0 0 1 1 1 1 

× 

a 4 

a 3 

⊕ 

0 

0 

⎜1 1 0 0 0 1 1 1 

⎟ ⎜a 2 

⎟ ⎜0 

⎟ 

⎝1 1 1 0 0 0 1 1⎠ 

⎝a 1 

⎠ ⎝1⎠ 

1 1 1 1 0 0 0 1 a 0 1

SubBytes 

Mittels Lagrange-Interpolation kann man zeigen: 

SBox(x) = 05 · x 254 + 09 · x 253 + F9 · x 251 + 25 · x 247 

+ F4 · x 239 + 01 · x 223 + B5 · x 191 + 8F · x 127 + 63

S −1 -Box 

S −1 -Box 0 1 2 3 4 5 6 7 8 9 A B C D E F 

0 52 09 6A D5 30 36 A5 38 BF 40 A3 9E 81 F3 D7 FB 

1 7C E3 39 82 9B 2F FF 87 34 8E 43 44 C4 DE E9 CB 

2 54 7B 94 32 A6 C2 23 3D EE 4C 95 0B 42 FA C3 4E 

3 08 2E A1 66 28 D9 24 B2 76 5B A2 49 6D 8B D1 25 

4 72 F8 F6 64 86 68 98 16 D4 A4 5C CC 5D 65 B6 92 

5 6C 70 48 50 FD ED B9 DA 5E 15 46 57 A7 8D 9D 84 

6 90 D8 AB 00 8C BC D3 0A F7 E4 58 05 B8 B3 45 06 

7 D0 2C 1E 8F CA 3F 0F 02 C1 AF BD 03 01 13 8A 6B 

8 3A 91 11 41 4F 67 DC EA 97 F2 CF CE F0 B4 E6 73 

9 96 AC 74 22 E7 AD 35 85 E2 F9 37 E8 1C 75 DF 6E 

A 47 F1 1A 71 1D 29 C5 89 6F B7 62 0E AA 18 BE 1B 

B FC 56 3E 4B C6 D2 79 20 9A DB C0 FE 78 CD 5A F4 

C 1F DD A8 33 88 07 C7 31 B1 12 10 59 27 80 EC 5F 

D 60 51 7F A9 19 B5 4A 0D 2D E5 7A 9F 93 C9 9C EF 

E A0 E0 3B 4D AE 2A F5 B0 C8 EB BB 3C 83 53 99 61 

F 17 2B 04 7E BA 77 D6 26 E1 69 14 63 55 21 0C 7D

InvSubBytes 

S −1 Box(x) = g −1 (f −1 (x)) = g(f −1 (x)) mit 

⎛ 

⎞ ⎛ ⎞ ⎛ ⎞ 

0 1 0 1 0 0 1 0 a 7 0 

0 0 1 0 1 0 0 1 

a 6 

0 

1 0 0 1 0 1 0 0 

a 5 

0 

f −1 (a) = 

0 1 0 0 1 0 1 0 

0 0 1 0 0 1 0 1 

× 

a 4 

a 3 

⊕ 

0 

0 

⎜1 0 0 1 0 0 1 0 

⎟ ⎜a 2 

⎟ ⎜1 

⎟ 

⎝0 1 0 0 1 0 0 1⎠ 

⎝a 1 

⎠ ⎝0⎠ 

1 0 1 0 0 1 0 0 a 0 1

ShiftRows

ShiftRows 

s ′ r,c = s r,c+Ci 

mod N b 

N b C 0 C 1 C 2 C 3 

4 0 1 2 3 

5 0 1 2 3 

6 0 1 2 3 

7 0 1 2 4 

8 0 1 3 4

ShiftRows 

s ′ r,c = s r,c+Ci 

mod N b 

N b C 0 C 1 C 2 C 3 

4 0 1 2 3 

5 0 1 2 3 

6 0 1 2 3 

7 0 1 2 4 

8 0 1 3 4 

Bei InvShiftRows wird C i durch N b − C i ersetzt, aber C 0 

bleibt 0.

MixColumns

MixColumns 

b 0 + b 1 x + b 2 x 2 + b 3 x 3 ≡ 

(02+01x +01x 2 +03x 3 )·(a 0 +a 1 x +a 2 x 2 +a 3 x 3 ) mod x 4 +1

MixColumns 

b 0 + b 1 x + b 2 x 2 + b 3 x 3 ≡ 

(02+01x +01x 2 +03x 3 )·(a 0 +a 1 x +a 2 x 2 +a 3 x 3 ) mod x 4 +1 

⇒ Matrixmultiplikation: 

⎛ ⎞ ⎛ 

⎞ ⎛ ⎞ 

b 0 02 03 01 01 a 0 

⎜b 1 

⎟ 

⎝b 2 

⎠ = ⎜01 02 03 01 

⎟ 

⎝01 01 02 03⎠ × ⎜a 1 

⎟ 

⎝a 2 

⎠ 

b 3 03 01 01 02 a 3

InvMixColumns 

c(x) = (02 + 01x + 01x 2 + 03x 3 ) 

Da ggT (c(x), x 4 + 1) = 1, gibt es ein Polynom d(x) mit 

c(x) · d(x) ≡ 1 mod (x 4 + 1)

InvMixColumns 

c(x) = (02 + 01x + 01x 2 + 03x 3 ) 

Da ggT (c(x), x 4 + 1) = 1, gibt es ein Polynom d(x) mit 

c(x) · d(x) ≡ 1 mod (x 4 + 1) 

Mit dem erw. Euklidischen Algorithmus für Polynome erhält 

man 

d(x) = 0Bx 3 + 0Dx 2 + 09x + 0E 

⎛ ⎞ ⎛ 

⎞ ⎛ ⎞ 

b 0 0E 0B 0D 09 a 0 

⇒ ⎜b 1 

⎟ 

⎝b 2 

⎠ = ⎜09 0E 0B 0D 

⎟ 

⎝0D 09 0E 0B⎠ × ⎜a 1 

⎟ 

⎝a 2 

⎠ 

b 3 0B 0D 09 0E a 3

AddRoundKey

KeyExpansion 

Die Spalten des Key-Arrays werden als 32-bit-Wörter 

aufgefasst und mit w[i] bezeichnet.

KeyExpansion 


aufgefasst und mit w[i] bezeichnet. 

SubWord(w[i]) wendet die S-Box auf jedes einzelne Byte aus 

w[i] an.

KeyExpansion 




w[i] an. 

RotWord(w[i]) nimmt ein Wort [a, b, c, d] und gibt das 

Wort [b, c, d, a] zurück.

KeyExpansion 




w[i] an. 

RotWord(w[i]) nimmt ein Wort [a, b, c, d] und gibt das 

Wort [b, c, d, a] zurück. 

Rcon[i] = [2 i−1 , 0, 0, 0] für 1 ≤ i ≤ N r

KeyExpansion 

w[1] w[2] w[3] . . . 

k 0 k 4 k 8 k 12 k 16 k 20 . . . 

k 1 k 5 k 9 k 13 k 17 k 21 . . . 

k 2 k 6 k 10 k 14 k 18 k 22 . . . 

k 3 k 7 k 11 k 15 k 19 k 23 . . .

KeyExpansion 

k i−N k 

0 

k i−N k 

1 

k i−N k 

2 

k i−N k 

3 

⊕ 

k i−1 

0 

k i−1 

1 

k i−1 

2 

k i−1 

3 

= 

k i 0 

k i 1 

k i 2 

k i 3

KeyExpansion 

Wenn i mod N k = 0: 

k i−1 

0 

k i−1 

1 

k i−1 

2 

k i−1 

3

KeyExpansion 


k i−1 

1 

k i−1 

2 

k i−1 

3 

k i−1 

0

KeyExpansion 


S(k1 i−1 ) 

S(k2 i−1 ) 

S(k3 i−1 ) 

S(k0 i−1 )

KeyExpansion 


k i−N k 

0 

k i−N k 

1 

k i−N k 

2 

k i−N k 

3 

⊕ 

S(k1 i−1 ) 

S(k2 i−1 ) 

S(k3 i−1 ) 

S(k0 i−1 )

KeyExpansion 


k i−N k 

0 

k i−N k 

1 

k i−N k 

2 

k i−N k 

3 

⊕ 

S(k1 i−1 ) 

S(k2 i−1 ) 

S(k3 i−1 ) 

S(k0 i−1 ) 

⊕ 2i/N k 

0 

0 

0

KeyExpansion 


k i−N k 

0 

k i−N k 

1 

k i−N k 

2 

k i−N k 

3 

⊕ 

S(k1 i−1 ) 

S(k2 i−1 ) 

S(k3 i−1 ) 

S(k0 i−1 ) 

⊕ 2i/N k 

0 

0 

0 

= 

k i 0 

k i 1 

k i 2 

k i 3

KeyExpansion 

Wenn N k > 6 und i mod N k = 4: 

k i−N k 

0 

k i−N k 

1 

k i−N k 

2 

k i−N k 

3 

⊕ 

S(k0 i−1 ) 

S(k1 i−1 ) 

S(k2 i−1 ) 

S(k3 i−1 ) 

= 

k i 0 

k i 1 

k i 2 

k i 3

KeyExpansion 

RoundKey[0] 

RoundKey[1] 

w[1] w[2] w[3] w[4] w[5] w[6] w[7] w[8] · · ·

KeyExpansion 

KeyExpansion 

{ 

for i = 0 to Nk-1 do 

w[i] = k[i]; 

for i = Nk to Nb(Nk+1) do 

{ 

temp = w[i-1] 

if (i mod Nk = 0) 

temp = SubWord(RotWord(temp)) XOR Rcon[i/Nk]; 

else if (Nk > 6 and i mod Nk = 4) 

temp = SubWord(temp); 

} 

} 

w[i] = w[i-Nk] XOR temp;

KeyExpasion 

Da die Konstante der affinen Abbildung der 

S-Box-Transformation auf jedes Byte des Zustands addiert 

wird, kann man diese in eine leicht modifizierte KeyExpansion 

verlagern.

KeyExpasion 




verlagern. 

Die Schritte der KeyExpansion lassen sich auch invertieren, 

d.h. mit Kenntnis eines beliebigen Blocks von N k 

benachbarten Spalten können alle anderen Rundenschlüssel 

berechnet werden.

KeyExpasion 




verlagern. 




berechnet werden. 

Nur den CipherKey selbst wählen, nicht die ganzen 

Rundenschlüssel!

KeyExpasion 




verlagern. 




berechnet werden. 

Nur den CipherKey selbst wählen, nicht die ganzen 

Rundenschlüssel! 

keine weak-keys wie in DES

Inhalt 

1 Einführung 


3 Kryptoanalyse

Arten der Kryptoanalyse 

Brute-Force-Angriff: vollständiges Durchsuchen des 

Schlüsselraumes



Schlüsselraumes 

known-plaintext-Angriff: Der Angreifer hat Zugriff auf eine 

bestimmte Anzahl von Klartexten und zugehörigen 

Chiffretexten bzgl. eines (unbekannten) Schlüssels.



Schlüsselraumes 

known-plaintext-Angriff: Der Angreifer hat Zugriff auf eine 

bestimmte Anzahl von Klartexten und zugehörigen 

Chiffretexten bzgl. eines (unbekannten) Schlüssels. 

chosen-plaintext-Angriff: Der Angreifer hat die Möglichkeit, 

eine bestimmte Anzahl an Klartexten frei zu wählen und die 

zugehörigen Chiffretexte bzgl. eines (unbekannten) Schlüssels 

zu bestimmen.

Inhalt 

1 Einführung 


3 Kryptoanalyse 

Differentielle Kryptoanalyse 

Lineare Kryptoanalyse 

Algebraische Angriffe


wurde 1990 von Biham und Shamir entwickelt, wurde 

allerdings schon in den 70er Jahren bei der Entwicklung von 

DES berücksichtigt




DES berücksichtigt 

chosen-plaintext-Angriff: Der Angreifer wählt Klartextpaare 

(P, P ′ ) mit der selben Differenz ∆P = P ⊕ P ′ , und versucht 

damit den letzten Rundenschlüssel zu berechnen. (ist 

N k > N b , werden die letzten beiden Rundenschlüssel benötigt)








N k > N b , werden die letzten beiden Rundenschlüssel benötigt) 

Um an den letzten Rundenschlüssel zu kommen wird versucht, 

die Differenz ∆Z am Ende der letzten Runde (vor der 

Schlüsseladdition) mit einer hohen Wahrscheinlichkeit zu 

bestimmen.












bestimmen. 

Aus ∆Z und ∆C lässt sich dann der letzte Rundenschlüssel 

berechnen (und damit der ganze Schlüssel).












bestimmen. 


berechnen (und damit der ganze Schlüssel). 

perfekt zufällige Chiffre: P(∆Z | ∆X ) = 1/2 n (mathematisch 

nicht möglich)












bestimmen. 


berechnen (und damit der ganze Schlüssel). 

perfekt zufällige Chiffre: P(∆Z | ∆X ) = 1/2 n (mathematisch 

nicht möglich) 

Es wird versucht, Paare (∆X , ∆Z) zu finden mit 

P(∆Z | ∆X ) ≫ 1/2 n

Differentielle Kryptoanalyse - Die linearen Schritte 

Für eine Lineare Abbildung L gilt: L(x) ⊕ L(y) = L(x ⊕ y)


Für eine Lineare Abbildung L gilt: L(x) ⊕ L(y) = L(x ⊕ y) 

Also gilt für zwei Zustände X , X ′ mit X ′ = X ⊕ ∆X : 

SR(X ) ⊕ SR(X ′ ) = SR(X ⊕ X ′ ) = SR(∆X )




SR(X ) ⊕ SR(X ′ ) = SR(X ⊕ X ′ ) = SR(∆X ) 

MC(X ) ⊕ MC(X ′ ) = MC(X ⊕ X ′ ) = MC(∆X )




SR(X ) ⊕ SR(X ′ ) = SR(X ⊕ X ′ ) = SR(∆X ) 

MC(X ) ⊕ MC(X ′ ) = MC(X ⊕ X ′ ) = MC(∆X ) 

(X ⊕ K) ⊕ (X ′ ⊕ K) = X ⊕ X ′ = ∆X

Differentielle Kryptoanalyse - Eine einfache S-Box 

X Y 

000 011 

001 111 

010 101 

011 001 

100 100 

101 010 

110 000 

111 110

Differentielle Kryptoanalyse - Eine einfache S-Box 

X Y 

000 011 

001 111 

010 101 

011 001 

100 100 

101 010 

110 000 

111 110 

∆Y 

∆X = 010 ∆X = 011 ∆X = 111 ∆X = . . . 

110 010 101 . . . 

110 010 111 . . . 

110 010 111 . . . 

110 010 101 . . . 

100 010 101 . . . 

100 010 111 . . . 

100 010 111 . . . 

100 010 101 . . . 

4 × 110 8 × 010 4 × 111 . . . 

4 × 100 4 × 101 . . .

Differenzenverteilungstabelle 

∆Y = 000 001 010 011 100 101 110 111 

∆X = 000 8 0 0 0 0 0 0 0 

001 0 0 0 0 4 0 4 0 

010 0 0 0 0 4 0 4 0 

011 0 0 8 0 0 0 0 0 

100 0 0 0 0 0 4 0 4 

101 0 4 0 4 0 0 0 0 

110 0 4 0 4 0 0 0 0 

111 0 0 0 0 0 4 0 4


Zeilensumme = 2 n = 8


Zeilensumme = 2 n = 8 

Spaltensumme = 2 n = 8



Spaltensumme = 2 n = 8 

Eine Eingangsdifferenz ∆X = 0 wird mit jedem Schlüssel auf 

eine Ausgangsdifferenz ∆Y = 0 abgebildet, deswegen ist das 

linke obere Element 8 und die restlichen Elemente in der 1. 

Zeile und 1. Spalte 0.







Zeile und 1. Spalte 0. 

Alle Elemente sind gerade, weil ∆X = X ⊕ X ′ = X ′ ⊕ X .







Zeile und 1. Spalte 0. 

Alle Elemente sind gerade, weil ∆X = X ⊕ X ′ = X ′ ⊕ X . 

nur 1 oder 2 mögliche Ausgangsdifferenzen pro 

Eingangsdifferenz (wenig benötigte Klartextpaare)

Differenzenverteilungstabelle der Rijndael-S-Box 

(Ausschnitt) 

∆Y = 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F . . . 

∆X = 00 256 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 . . . 

01 0 2 0 0 2 0 2 0 2 2 2 2 2 2 2 2 . . . 

02 0 0 0 2 2 2 2 2 0 0 0 2 2 2 0 2 . . . 

03 0 0 2 0 2 2 0 0 2 0 2 2 2 0 0 0 . . . 

04 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 . . . 

05 0 0 0 0 2 0 0 0 4 2 0 0 2 2 0 0 . . . 

06 0 2 0 0 2 2 0 0 0 2 0 2 4 0 2 0 . . . 

07 0 2 0 0 0 0 2 0 2 2 2 0 0 0 0 0 . . . 

08 0 0 2 2 0 0 0 0 0 2 0 2 2 0 0 2 . . . 

09 0 0 2 2 0 0 2 2 0 0 0 0 2 0 2 0 . . . 

0A 0 0 2 2 4 0 2 2 0 2 2 0 2 0 0 2 . . . 

0B 0 2 0 0 0 0 0 2 2 2 0 0 2 2 2 2 . . . 

0C 0 0 2 2 0 0 2 2 2 2 2 0 0 2 0 2 . . . 

0D 0 2 2 0 0 0 2 2 2 2 2 2 0 0 0 2 . . . 

0E 0 0 2 2 2 2 0 2 2 0 2 2 0 0 0 0 . . . 

0F 0 0 2 2 2 0 0 0 2 0 2 0 2 0 0 2 . . . 

. . . . . . . . . . . . . . . . . 

. ..



Spaltensumme = 2 n = 256




pro Eingangsbelegung 127 mögliche Ausgangsbelegungen




pro Eingangsbelegung 127 mögliche Ausgangsbelegungen 

126 mit Wahrscheinlichkeit 

2 

256





2 


256 

4 


256





2 


256 

4 


256 

128 mit Wahrscheinlichkeit 0





2 


256 

4 


256 

128 mit Wahrscheinlichkeit 0 

außer für ∆X = 0


Um Informationen über ∆Z (der Eingang der lezten 

Rundenschlüsseladdition) zu erhalten, wird eine beliebige feste 

Differenz ∆P gewählt. (alle ∆P ≠ 0 gleichwertig)




Differenz ∆P gewählt. (alle ∆P ≠ 0 gleichwertig) 

Mittels einer sog. Charakteristik 

Q = (q (0) , q (1) , . . . , q (r−1) , q (r) ) wird das ∆Z mit der 

höchsten Wahrscheinlichkeit ermittelt.







höchsten Wahrscheinlichkeit ermittelt. 

q (i) = Differenz nach der i-ten Runde, also q (0) = ∆P und 

q (r) = ∆Z









q (r) = ∆Z 

q (i+1) ist dasjenige Byte, das bzgl. q (i) die maximale 

4 

Wahrscheinlichkeit 

256 = 1 

64 aufweist.









q (r) = ∆Z 

q (i+1) ist dasjenige Byte, das bzgl. q (i) die maximale 

4 

Wahrscheinlichkeit 

256 = 1 

64 aufweist. 

Dann werden auf q (i+1) die linearen Operationen inkl. der 

Schlüsseladdition ausgeführt.


P(Q) = 

( ) 1 (4·Nb ) Nr 

64


P(Q) = 

( ) 1 (4·Nb ) Nr 

64 

Die Anzahl der benötigten Klartextpaare (mit den 

dazugehörigen Chiffretextpaaren) ist proportional zu 

1 

P(Q) .


P(Q) = 

( ) 1 (4·Nb ) Nr 

64 



1 

P(Q) . 

Das ist viel zu viel, um gespeichert und verwaltet zu werden.


P(Q) = 

( ) 1 (4·Nb ) Nr 

64 



1 

P(Q) . 

Das ist viel zu viel, um gespeichert und verwaltet zu werden. 

Die Anzahl steigt exponentiell mit der Anzahl der Runden N r .

Inhalt 

1 Einführung 







1993 von Matsui entwickelt


1993 von Matsui entwickelt 

known-plaintext-Angriff



known-plaintext-Angriff 

braucht für DES nur 2 43 Klartexte



known-plaintext-Angriff 

braucht für DES nur 2 43 Klartexte 

Idee: nichtlinearen Teil der Chiffre durch eine lineare Funktion 

approximieren

Lineare Kryptoanalyse - kleines Beispiel 

Sei F (a, b, c) = abc ⊕ bc ⊕ b ⊕ c eine binäre nichtlineare 

Funktion.

Lineare Kryptoanalyse - kleines Beispiel 

Sei F (a, b, c) = abc ⊕ bc ⊕ b ⊕ c eine binäre nichtlineare 

Funktion. 

a b c F a ⊕ b a ⊕ c b ⊕ c a ⊕ b ⊕ c ⊕ 1 

0 0 0 0 0 0 0 1 

0 0 1 1 0 1 1 0 

0 1 0 1 1 0 1 0 

0 1 1 1 1 1 0 1 

1 0 0 0 1 1 0 0 

1 0 1 1 1 0 1 1 

1 1 0 1 0 1 1 1 

1 1 1 0 0 0 0 0 

3 5 5 8 5 5 7 5


S-Box, die n Bit substituiert, also 

X = X 1 . . . X n → Y = Y 1 . . . Y n



X = X 1 . . . X n → Y = Y 1 . . . Y n 

Es werden Gleichungen der Form 

X i1 ⊕ X i2 ⊕ · · · ⊕ X iu ⊕ Y j1 ⊕ Y j2 ⊕ · · · ⊕ Y jv = 0



X = X 1 . . . X n → Y = Y 1 . . . Y n 


bzw. 

X i1 ⊕ X i2 ⊕ · · · ⊕ X iu ⊕ Y j1 ⊕ Y j2 ⊕ · · · ⊕ Y jv = 0 

X i1 ⊕ X i2 ⊕ · · · ⊕ X iu = Y j1 ⊕ Y j2 ⊕ · · · ⊕ Y jv 

mit 1 ≤ i k , j k ≤ n aufgestellt.



X = X 1 . . . X n → Y = Y 1 . . . Y n 


bzw. 

X i1 ⊕ X i2 ⊕ · · · ⊕ X iu ⊕ Y j1 ⊕ Y j2 ⊕ · · · ⊕ Y jv = 0 

X i1 ⊕ X i2 ⊕ · · · ⊕ X iu = Y j1 ⊕ Y j2 ⊕ · · · ⊕ Y jv 

mit 1 ≤ i k , j k ≤ n aufgestellt. 

Wir haben sowohl für die Belegung der i k als auch der j k 

jeweils 2 n = 256 Möglichkeiten.


Bezeichne Γ I den n-Bitvektor, der die Belegung der i k 

markiert und Γ O den n-Bitvektor für die j k -Belegung.



markiert und Γ O den n-Bitvektor für die j k -Belegung. 

Nun lässt man Γ I und Γ O von 0 bis 255 durchlaufen und zählt 

für jede Gleichung X Γ I ⊕ Y Γ O = 0, wie oft sie wahr ist.





für jede Gleichung X Γ I ⊕ Y Γ O = 0, wie oft sie wahr ist. 

Für eine perfekt zufällige Chiffre ist jede dieser Gleichungen 

mit Wahrscheinlichkeit 1 2 wahr.







mit Wahrscheinlichkeit 1 2 wahr. 

Ziel ist es Gleichungen zu finden, die mit einer 

Wahrscheinlichkeit wahr werden, die möglichst stark von 1 2 

abweichen.







mit Wahrscheinlichkeit 1 2 wahr. 

Ziel ist es Gleichungen zu finden, die mit einer 

Wahrscheinlichkeit wahr werden, die möglichst stark von 1 2 

abweichen.

Lineare Approximationstabelle der Rijndael-S-Box 

(Ausschnitt) 

Γ O = 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F . . . 

Γ I = 00 128 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 . . . 

01 0 12 0 12 14 6 2 -6 12 0 8 12 2 10 2 -6 . . . 

02 0 2 8 -6 2 -8 2 0 6 -4 -6 0 8 2 12 -2 . . . 

03 0 6 8 -2 12 2 0 -2 -6 12 10 -4 6 0 10 12 . . . 

04 0 -8 2 -2 6 2 -4 -12 6 -6 -8 8 12 -4 10 -2 . . . 

05 0 8 10 6 -12 12 -2 2 14 -14 -4 12 -14 6 8 16 . . . 

06 0 6 6 8 8 -2 2 4 12 -6 6 -8 -4 2 -6 -12 . . . 

07 0 -10 2 0 -6 -4 -8 -10 -4 10 2 4 6 -16 12 -6 . . . 

08 0 2 2 4 4 6 2 4 0 -10 -14 8 4 -6 10 16 . . . 

09 0 -10 -2 4 6 8 4 -10 8 2 2 12 -2 -4 -16 14 . . . 

0A 0 -4 -10 2 14 6 8 -8 -6 14 -12 -8 8 -8 -10 -2 . . . 

0B 0 0 2 2 -4 4 10 6 -6 2 -4 4 -2 6 8 -8 . . . 

0C 0 -6 4 10 10 0 -2 8 -6 -12 6 4 12 -6 8 2 . . . 

0D 0 -14 0 -2 12 -10 8 6 -2 8 10 8 -6 12 2 16 . . . 

0E 0 8 12 8 -4 4 8 -12 12 16 12 12 8 4 0 -8 . . . 

0F 0 8 -8 -12 -14 -10 6 14 8 4 8 16 -6 2 14 2 . . . 

. . . . . . . . . . . . . . . . 

. ..


Die Einträge der Tabelle beschreiben, wie oft X Γ I ⊕ Y Γ O = 0 

gilt, minus 128.



gilt, minus 128. 

Damit gilt 

P(Γ I , Γ O ) = 

1 

∣2 − Tabelleneintrag 

256 ∣




Damit gilt 

P(Γ I , Γ O ) = 

1 


256 ∣ 

In jeder Zeile (bis auf die 1.) ist der maximale Betrag 16.




Damit gilt 

P(Γ I , Γ O ) = 

1 


256 ∣ 

In jeder Zeile (bis auf die 1.) ist der maximale Betrag 16. 

Um von einer S-Box auf eine ganze Runde zu schließen, ist 

nicht schwer, da die linearen Transformationen einfach auf Y 

übertragen werden können.




Damit gilt 

P(Γ I , Γ O ) = 

1 


256 ∣ 

In jeder Zeile (bis auf die 1.) ist der maximale Betrag 16. 

Um von einer S-Box auf eine ganze Runde zu schließen, ist 

nicht schwer, da die linearen Transformationen einfach auf Y 

übertragen werden können. 

Um von einer Runde auf mehrere schließen zu können, 

braucht man das Piling-Up Lemma.

Piling-Up Lemma 

Seien X 1 und X 2 binäre Zufallsvariablen mit 

P(X 1 = i) = 

P(X 2 = i) = 

{ 

p1 , i = 0 

1 − p 1 , i = 1 

{ 

p2 , i = 0 

1 − p 2 , i = 1


Seien X 1 und X 2 binäre Zufallsvariablen mit 

P(X 1 = i) = 

P(X 2 = i) = 

{ 

p1 , i = 0 

1 − p 1 , i = 1 

{ 

p2 , i = 0 

1 − p 2 , i = 1 

Wenn X 1 und X 2 unabhängig: 

⎧ 

p 1 p 2 , i = 0, j = 0 

⎪⎨ 

p 

P(X 1 = i, X 2 = j) = 1 (1 − p 2 ) , i = 0, j = 1 

(1 − p ⎪⎩ 

1 )p 2 , i = 1, j = 0 

(1 − p 1 )(1 − p 2 ) , i = 1, j = 1


Daraus folgt: 

P(X 1 ⊕ X 2 = 0) = P(X 1 = X 2 )


Daraus folgt: 

P(X 1 ⊕ X 2 = 0) = P(X 1 = X 2 ) 

= P(X 1 = 0, X 2 = 0) + P(X 1 = 1, X 2 = 1)


Daraus folgt: 

P(X 1 ⊕ X 2 = 0) = P(X 1 = X 2 ) 

= P(X 1 = 0, X 2 = 0) + P(X 1 = 1, X 2 = 1) 

= p 1 p 2 + (1 − p 1 )(1 − p 2 )


Daraus folgt: 

P(X 1 ⊕ X 2 = 0) = P(X 1 = X 2 ) 

= P(X 1 = 0, X 2 = 0) + P(X 1 = 1, X 2 = 1) 

= p 1 p 2 + (1 − p 1 )(1 − p 2 ) 

Mit p 1 = 1 2 + ε 1 und p 2 = 1 2 + ε 2 ergibt sich: 

P(X 1 ⊕ X 2 = 0) = ( 1 2 + ε 1)( 1 2 + ε 2) + ( 1 2 − ε 1)( 1 2 − ε 2)


Daraus folgt: 

P(X 1 ⊕ X 2 = 0) = P(X 1 = X 2 ) 

= P(X 1 = 0, X 2 = 0) + P(X 1 = 1, X 2 = 1) 

= p 1 p 2 + (1 − p 1 )(1 − p 2 ) 


P(X 1 ⊕ X 2 = 0) = ( 1 2 + ε 1)( 1 2 + ε 2) + ( 1 2 − ε 1)( 1 2 − ε 2) 

= 1 4 + 1 2 (ε 1 + ε 2 ) + ε 1 ε 2 + 

1 

4 − 1 2 (ε 1 + ε 2 ) + ε 1 ε 2


Daraus folgt: 

P(X 1 ⊕ X 2 = 0) = P(X 1 = X 2 ) 

= P(X 1 = 0, X 2 = 0) + P(X 1 = 1, X 2 = 1) 

= p 1 p 2 + (1 − p 1 )(1 − p 2 ) 


P(X 1 ⊕ X 2 = 0) = ( 1 2 + ε 1)( 1 2 + ε 2) + ( 1 2 − ε 1)( 1 2 − ε 2) 

= 1 4 + 1 2 (ε 1 + ε 2 ) + ε 1 ε 2 + 

1 

4 − 1 2 (ε 1 + ε 2 ) + ε 1 ε 2 

= 1 2 + 2ε 1ε 2


Sei ε 12 die Abweichung für X 1 ⊕ X 2 = 0, dann gilt also: 

ε 12 = 2ε 1 ε 2 .



ε 12 = 2ε 1 ε 2 . 

Das lässt sich für n binäre Zufallsvariablen erweitern: 

P(X 1 ⊕ · · · ⊕ X n = 0) = 1 2 + 2n−1 

n∏ 

i=1 

ε i



ε 12 = 2ε 1 ε 2 . 

Das lässt sich für n binäre Zufallsvariablen erweitern: 

P(X 1 ⊕ · · · ⊕ X n = 0) = 1 2 + 2n−1 

n∏ 

i=1 

ε i 

bzw. 

ε 1...n = 2 n−1 

n∏ 

i=1 

ε i


PΓ I ⊕ CΓ O = KΓ K


PΓ I ⊕ CΓ O = KΓ K 

(Γ I , Γ O ) unkorreliert ⇒ P(KΓ K = 0) = P(KΓ K = 1) = 1 2



(Γ I , Γ O ) unkorreliert ⇒ P(KΓ K = 0) = P(KΓ K = 1) = 1 2 

Wird die linke Seite mit einer signifikant höheren 

Wahrscheinlichkeit als 1 2 wahr, so kann ich raten“, dass 

” 

KΓ K = 0,






” 

KΓ K = 0, 

und bei einer sehr niedrigen Wahrscheinlichkeit KΓ K = 1.






” 

KΓ K = 0, 

und bei einer sehr niedrigen Wahrscheinlichkeit KΓ K = 1. 

Sei ε die Abweichung für die gesamte Chiffre. Dann berechnet 

sich die Erfolgswahrscheinlichkeit zum Raten eines Bits 

Schlüsselinformation: 

∫ ∞ 

−2 √ N|ε| 

1 

√ 

2π 

e −x2 /2 dx 

wobei N die Anzahl der bekannten Klartexte ist.






” 

KΓ K = 0, 

und bei einer sehr niedrigen Wahrscheinlichkeit KΓ K = 1. 

Sei ε die Abweichung für die gesamte Chiffre. Dann berechnet 

sich die Erfolgswahrscheinlichkeit zum Raten eines Bits 

Schlüsselinformation: 

∫ ∞ 

−2 √ N|ε| 

1 

√ 

2π 

e −x2 /2 dx 

wobei N die Anzahl der bekannten Klartexte ist. 

N ∼ 1/ε 2


Erfolgsrate für eine AES-Runde mit ε i = 1 

16 : 

1/4|ε i | −2 1/2|ε i | −2 |ε i | −2 2|ε i | −2 

N = 64 = 128 = 256 = 512 

Erfolgsrate 81.4% 92.1% 97.7% 99.8%


Da die S-Boxen parallel ausgeführt werden und sich nicht 

beeinflussen, können für jede S-Box die gleichen Bits 

approximiert werden.




approximiert werden. 

Da für jede S-Box eine Gleichung mit ε = 16 

16 gefunden 

werden kann, ergibt sich für die gesamte i-te Runde eine 

Abweichung von ε i = 1 

16 . 

256 = 1




approximiert werden. 

Da für jede S-Box eine Gleichung mit ε = 16 

16 gefunden 

werden kann, ergibt sich für die gesamte i-te Runde eine 

Abweichung von ε i = 1 

16 . 

Unter der Annahme, dass die Inputs zu den einzelnen Runden 

stochastisch unabhängig sind, kann man mit Hilfe des 

Piling-Up Lemmas nun die Abweichung ε für eine gesamte 

AES-Verschlüsselung berechnen: 

P = 1 2 + 29 10∑ 

i=1 

256 = 1 

1 

16 = 1 ( ) 1 10 

2 + 1 

29 · 

16 2 + 29 

(2 4 ) 10 = 1 2 + 2−31


Daraus folgt, dass N = 2 · ε 2 = 2 · (2 −31 ) 2 = 2 65 Klartexte 

benötigt werden für eine Erfolgsrate von 99.8%. 

AES-256: ε = 2 −43 ⇒ N ≈ 2 87


Daraus folgt, dass N = 2 · ε 2 = 2 · (2 −31 ) 2 = 2 65 Klartexte 

benötigt werden für eine Erfolgsrate von 99.8%. 

AES-256: ε = 2 −43 ⇒ N ≈ 2 87 

N steigt exponentiell mit der Anzahl der Runden.

Inhalt 

1 Einführung 






AES als Kettenbruch 

2001 fanden Leute vom Twofish-Team eine elegante 

algebraische Repräsentation für AES, welche als Kettenbruch 

aufgefasst werden kann.




aufgefasst werden kann. 

Dazu betrachten wir die S-Box: 

SBox(x) = 05 · x 254 + 09 · x 253 + F9 · x 251 + 25 · x 247 

+F4 · x 239 + 01 · x 223 + B5 · x 191 + 8F · x 127 + 63




aufgefasst werden kann. 

Dazu betrachten wir die S-Box: 

SBox(x) = 05 · x 254 + 09 · x 253 + F9 · x 251 + 25 · x 247 

+F4 · x 239 + 01 · x 223 + B5 · x 191 + 8F · x 127 + 63 

7∑ 

SBox(x) = w 8 + w d x 255−2d 

d=0


7∑ 

SBox(x) = w 8 + w d x 255−2d 

d=0 

Die Konstante w 8 = 63 wird in die KeyExpansion verlagert.


7∑ 

SBox(x) = w 8 + w d x 255−2d 

d=0 

Die Konstante w 8 = 63 wird in die KeyExpansion verlagert. 

∀x ≠ 0 ∈ GF (2 8 ) : x k k mod 255 

≡ x


7∑ 

SBox(x) = w 8 + w d x 255−2d 

d=0 


∀x ≠ 0 ∈ GF (2 8 ) : x k k mod 255 

≡ x 

⇒ ∀x ≠ 0 : x 255 ≡ 1


7∑ 

SBox(x) = w 8 + w d x 255−2d 

d=0 


∀x ≠ 0 ∈ GF (2 8 ) : x k k mod 255 

≡ x 

⇒ ∀x ≠ 0 : x 255 ≡ 1 

7∑ 

SBox(x) = w d x −2d 

d=0


Sei a (r) 

i,j 

das Byte an Pos. (i, j) im Input von Runde r


Sei a (r) 

i,j 

s (r) 

i,j 

das Byte an Pos. (i, j) im Input von Runde r 

das Byte an Pos. (i, j) im Zustand nach SubBytes


Sei a (r) 

i,j 

s (r) 

i,j 

t (r) 

i,j 


das Byte an Pos. (i, j) im Zustand nach SubBytes 

das Byte an Pos. (i, j) im Zustand nach ShiftRows


Sei a (r) 

i,j 

s (r) 

i,j 

t (r) 

i,j 

m (r) 

i,j 



das Byte an Pos. (i, j) im Zustand nach ShiftRows 

das Byte an Pos. (i, j) im Zustand nach MixColumns


Sei a (r) 

i,j 

s (r) 

i,j 

t (r) 

i,j 

m (r) 

i,j 

v i,j 




das Byte an Pos. (i, j) im Zustand nach MixColumns 

Koeffizienten der MixColumns-Matrix


Sei a (r) 

i,j 

s (r) 

i,j 

t (r) 

i,j 

m (r) 

i,j 

v i,j 

k (r) 

i,j 




das Byte an Pos. (i, j) im Zustand nach MixColumns 

Koeffizienten der MixColumns-Matrix 

das Byte an Pos. (i, j) im Rundenschlüssel


s (r) 

i,j 

= SBox(a (r) 

i,j ) = 

7∑ 

d r =0 

w dr (a (r) 

i,j )−2dr


s (r) 

i,j 

= SBox(a (r) 

i,j ) = 

t (r) 

i,j 

= s (r) 

i,i+j = 

7∑ 

d r =0 

7∑ 

d r =0 

w dr (a (r) 

i,j )−2dr 

w dr (a (r) 

i,i+j )−2dr


s (r) 

i,j 

= SBox(a (r) 

i,j ) = 

t (r) 

i,j 

= s (r) 

i,i+j = 

m (r) 

i,j 

= 

3∑ 

e r =0 

7∑ 

d r =0 

v i,er t (r) 

e r ,j 

7∑ 

d r =0 

w dr (a (r) 

i,j )−2dr 

w dr (a (r) 

i,i+j )−2dr


s (r) 

i,j 

= SBox(a (r) 

i,j ) = 

t (r) 

i,j 

= s (r) 

i,i+j = 

m (r) 

i,j 

= 

= 

3∑ 

e r =0 

3∑ 

7∑ 

d r =0 

v i,er t (r) 

e r ,j 

7∑ 

v i,er 

e r =0 d r =0 

7∑ 

d r =0 

w dr (a (r) 

i,j )−2dr 

w dr (a (r) 

i,i+j )−2dr 

w dr (a (r) 

e r ,e r+j 

) −2dr


s (r) 

i,j 

= SBox(a (r) 

i,j ) = 

t (r) 

i,j 

= s (r) 

i,i+j = 

m (r) 

i,j 

= 

= 

= 

3∑ 

e r =0 

3∑ 

7∑ 

d r =0 

v i,er t (r) 

e r ,j 

v i,er 

e r =0 d r =0 

3∑ 

7∑ 

e r =0 d r =0 

7∑ 

7∑ 

d r =0 

w dr (a (r) 

i,j )−2dr 

w dr (a (r) 

i,i+j )−2dr 

w dr (a (r) 

e r ,e r+j 

) −2dr 

w i,er ,d r 

(a (r) 

e r ,e r+j 

) −2dr


a (r+1) 

i,j 

= m (r) 

i,e r 

+ k (r) 

e r ,j


a (r+1) 

i,j 

= m (r) 

i,e r 

+ k (r) 

e r ,j 

= k (r) 

i,j 

+ ∑ e r ∈E 

d r ∈D 

mit E = {0, . . . , 3} und D = {0, . . . , 7} 

w i,er ,d r 

(a (r) 

e r ,e r+j 

) −2dr


a (r+1) 

i,j 

= m (r) 

i,e r 

+ k (r) 

e r ,j 

= k (r) 

i,j 

+ ∑ e r ∈E 

d r ∈D 

mit E = {0, . . . , 3} und D = {0, . . . , 7} 

= k (r) 

i,j 

+ ∑ e r ∈E 

d r ∈D 

w i,er ,d r 

(a (r) 

e r ,e r+j 

) −2dr 

w i,er ,d r 

(a (r) 

e r ,e r+j 

) 2dr


Gleichung für 2 Runden: 

a (3) 

i,j 

= k (2) 

i,j 

+ ∑ e 2 ∈E 

d 2 ∈D 

⎛ 

⎜ 

⎝ k(1) e 2 ,e 2 +j + ∑ e 1 ∈E 

d 1 ∈D 

w i,e2 ,d 2 

w e2 ,e 1 ,d 1 

( 

a (1) 

e 1 ,e 1 +e 2 +j 

⎞ 

⎟ 

) 2 d 1 ⎠ 

2 d 2



a (3) 

i,j 

= k (2) 

i,j 

+ ∑ e 2 ∈E 

d 2 ∈D 

⎛ 

⎜ 

⎝ k(1) e 2 ,e 2 +j + ∑ e 1 ∈E 

d 1 ∈D 

w i,e2 ,d 2 

w e2 ,e 1 ,d 1 

( 

a (1) 

e 1 ,e 1 +e 2 +j 

⎞ 

⎟ 

) 2 d 1 ⎠ 

Da wir in einem Körper mit Charakteristik 2 arbeiten, können wir 

Freshman’s Dream (a + b) 2 = a 2 + b 2 anwenden: 

2 d 2 

a (3) 

i,j 

= k (2) 

i,j 

+ ∑ e 2 ∈E 

d 2 ∈D 

( 

k (1) 

e 2 ,e 2 +j 

w i,e2 ,d 2 

) 2 d 2 

+ 

∑ 

e 1 ∈E 

d 1 ∈D 

w e2 ,e 1 ,d 1 

) 2 d 1 +d 2 

( 

a (1) 

e 1 ,e 1 +e 2 +j


Da alle Indizes und Exponenten bekannt (berechenbar) und 

unabhängig vom Klartext und Schlüssel sind, werden sie der 

Einfachheit halber durch ∗ ersetzt.




Einfachheit halber durch ∗ ersetzt. 

Alle (verschiedenen, aber bekannten) Konstanten w er ,e r−1 ,d r−1 

werden durch C ersetzt






werden durch C ersetzt 

und alle Schlüssel-Bytes k (r) 

i,j 

durch K.








i,j 

durch K. 

Da a (1) 

i,j 

= p 4j+i + k (0) 

i,j 

, wobei die p i ’s die Klartext-Bytes sind, 

ergibt sich:








i,j 

durch K. 

Da a (1) 

i,j 

= p 4j+i + k (0) 

i,j 

, wobei die p i ’s die Klartext-Bytes sind, 

ergibt sich: 

a (3) 

i,j 

= K + ∑ e 2 ∈E 

d 2 ∈D 

C 

K ∗ + ∑ e 1 ∈E 

d 1 ∈D 

C 

P ∗ ∗ + K ∗



a (6) 

i,j 

= K+ ∑ e 5 ∈E 

d 5 ∈D 

K ∗ + ∑ e 4 ∈E 

d 4 ∈D 

K ∗ + ∑ e 3 ∈E 

d 3 ∈D 

C 

C 

K ∗ + ∑ e 2 ∈E 

d 2 ∈D 

C 

C 

K ∗ + ∑ e 1 ∈E 

d 1 ∈D 

C 

K ∗ + P ∗ ∗


Wenn man diese Gleichung ausmultipliziert, erhält man eine 

Gleichung mit 2 25 Termen (|E| · |D| = 32 = 2 5 Terme pro 

Runde) der Form C/(K ∗ + p ∗ ∗).




Runde) der Form C/(K ∗ + p ∗ ∗). 

Für 10 Runden würde der Kryptoanalytiker diese Gleichung 

nehmen und 2 mal hintereinander ausführen. (2 26 Terme)






nehmen und 2 mal hintereinander ausführen. (2 26 Terme) 

Man braucht 2 26 /16 = 2 22 Klartext-Chiffretext-Paare, um 

genug Information zu haben, um die Gleichung lösen zu 

können.









können. 

Für AES-128 würde ein O(n 4 )- und für AES-256 ein 

O(n 7 )-Algorithmus reichen, um schneller als Brute-Force zu 

sein.









können. 

Für AES-128 würde ein O(n 4 )- und für AES-256 ein 

O(n 7 )-Algorithmus reichen, um schneller als Brute-Force zu 

sein. 

Es ist ein offenes Problem, ob Gleichungen dieser Form 

effizient berechnet werden können.

AES und das MQ-Problem

AES und das MQ-Problem 

MQ-Problem 

Eingabe: System von m multivariaten, quadratischen Gleichungen 

mit n Variablen x 1 , . . . , x n der Form 

∑ 

a i,j,k x i x j + ∑ b k x i + c k = 0 mit a i,j,k , b i , c k ∈ K 

i,j 

i 

Ausgabe: Belegung für {x 1 , . . . , x n }, so dass jede Gleichung erfüllt 

ist.


MQ-Problem 

Eingabe: System von m multivariaten, quadratischen Gleichungen 

mit n Variablen x 1 , . . . , x n der Form 

∑ 

a i,j,k x i x j + ∑ b k x i + c k = 0 mit a i,j,k , b i , c k ∈ K 

i,j 

i 

Ausgabe: Belegung für {x 1 , . . . , x n }, so dass jede Gleichung erfüllt 

ist. 

Satz 

Die Entscheidungsvariante des MQ-Problems ist NP-vollständig.


Das MQ-Problem ist schon länger Gegenstand der 

Kryptoanalyse, jedoch bisher nur für Public-Key-Systeme wie 

z.B. das HFE-Kryptosystem (Hidden Field Equations)




z.B. das HFE-Kryptosystem (Hidden Field Equations) 

Klassische Algorithmen (z.B. Buchberger’s Algorithmus, F4 

und F5) versuchen das MQ-Problem mit Hilfe von 

Gröbner-Basen zu lösen.







Gröbner-Basen zu lösen. 

Diese Algorithmen laufen im Allgemeinen in exponentieller 

Zeit und sind für quadratische Gleichungssysteme mit mehr 

als 15 Variablen nicht mehr praktikabel.










als 15 Variablen nicht mehr praktikabel. 

Wenn das Gleichungssystem allerdings hinreichend 

überbestimmt ist (m > n), gibt es effizientere Algorithmen 

zum lösen dieser Gleichungssysteme.










als 15 Variablen nicht mehr praktikabel. 

Wenn das Gleichungssystem allerdings hinreichend 

überbestimmt ist (m > n), gibt es effizientere Algorithmen 

zum lösen dieser Gleichungssysteme. 

Die Autoren der XSL-Attacke (später) haben für eine 

AES-Verschlüsselung ein dünnbesetztes (sparse), 

quadratisches Gleichungssystem aus m = 8000 Gleichungen 

mit n = 1600 Variablen aus GF (2) konstruiert.

Linearisierung 

Das Prinzip der Linearisierung ist leicht zu verstehen: Wir 

können gut lineare Gleichungssysteme lösen (O(n 3 ) mit 

Gauss-Elimination), aber schlecht quadratische 

Gleichungssysteme.





Gleichungssysteme. 

( ) n + 1 

Wenn das System m = quadratische Gleichungen 

2 

mit n Variablen hat, ersetzen wir Terme der Form x i x j durch 

neue Variablen y ij und 

( 

erhalten 

) 

so ein Lineares 

( ) 

n + 1 

n + 1 

Gleichungssystem mit Gleichungen und 

2 

2 

y-Variablen, die wir mit Gauss-Elimination bestimmen können.






( ) n + 1 


2 



( 

erhalten 

) 


( ) 

n + 1 

n + 1 


2 

2 

y-Variablen, die wir mit Gauss-Elimination bestimmen können. 

√ 

yii , i = 1, . . . , n liefert 2 mögliche Lösungen für die x i . Mit 

Hilfe der y ij kann dann die eindeutige Lösung bestimmt 

werden.






( ) n + 1 


2 



( 

erhalten 

) 


( ) 

n + 1 

n + 1 


2 

2 

y-Variablen, die wir mit Gauss-Elimination bestimmen können. 

√ 

yii , i = 1, . . . , n liefert 2 mögliche Lösungen für die x i . Mit 

Hilfe der y ij kann dann die eindeutige Lösung bestimmt 

werden. ( ) 1601 

Da für AES-128 = 1280800 ≫ 8000, schlägt der 

2 

Algorithmus fehl.

Relinearisierung 

1999 wurde der Algorithmus verfeinert, indem man ausnutzte, 

dass die y ij nicht unabhängig sind.



dass die y ij nicht unabhängig sind. 

Denn für 1 ≤ a, b, c, d ≤ n gilt: 

(x a x b )(x c x d ) = (x a x c )(x b x d ) = (x a x d )(x b x c )





(x a x b )(x c x d ) = (x a x c )(x b x d ) = (x a x d )(x b x c ) 

y ab y cd = y ac y bd = y ad y bc






y ab y cd = y ac y bd = y ad y bc 

Daraus werden zusätzliche Gleichungen generiert.







Daraus werden zusätzliche Gleichungen generiert. 

Dies kann erweitert werden für höhere Grade, z.B. Grad 6: 

y ab y cd y ef = y ad y be y cf = . . .







Daraus werden zusätzliche Gleichungen generiert. 

Dies kann erweitert werden für höhere Grade, z.B. Grad 6: 

y ab y cd y ef = y ad y be y cf = . . . 

Relinearisierung funktioniert für Gleichungssysteme aus εn 2 

Gleichungen mit n Variablen für 0 ≤ ε ≤ 1 2

XL-Algorithmus 

1 Jahr später wurde gezeigt, dass viele der Gleichungen 

höheren Grades, die durch Relinearisierung erzeugt werden, 

linear abhängig sind und somit eliminiert werden können.


1 Jahr später wurde gezeigt, dass viele der Gleichungen 

höheren Grades, die durch Relinearisierung erzeugt werden, 

linear abhängig sind und somit eliminiert werden können. 

Deshalb wurde XL (eXtended Linearisation) entwickelt, eine 

erweiterte Version der Relinearisierung.


1 Wähle einen Parameter D und bilde alle Produkte 

mit k ≤ D − 2 und l i die i-te Gleichung des Systems 

2 Gauss-Elimination 

k∏ 

x ij · l i 

3 Hoffe, dass mindestens eine univariate Gleichung entsteht und 

löse diese über dem Körper K. 

4 Vereinfache die Gleichungen und wiederhole den Algorithmus 

mit dem reduzierten Gleichungssystem. 

5 Linearisierung 

j=1

Wie ist D zu wählen? 

Ein größeres D bringt mehr (linear unabhängige) Gleichungen, 

aber auch mehr Terme.



aber auch mehr Terme. 

Ein zu kleines D bringt nicht genug linear unabhängige 

Gleichungen für eine Lösung mit Gauss-Elimination.



aber auch mehr Terme. 

Ein zu kleines D bringt nicht genug linear unabhängige 

Gleichungen für eine Lösung mit Gauss-Elimination. 

Wenn D zu groß ist, haben wir nichts anderes als 

Relinearisierung.


In Schritt 1 erhalten wir R ≈ 

( n 

mit T ≈ Termen. 

D) 

( ) n 

· m neue Gleichungen 

D − 2



( n 


D) 

Wir wählen ( das ) kleinste ( D, so dass 

n n 

R = m ≥ = T . 

D − 2 D) 

( ) n 


D − 2



( n 


D) 


n n 

R = m ≥ = T . 

D − 2 D) 

( n 

D) 

( ) n 


D − 2 

R ≥ T ⇒ m ≥ 

( ) ≈ n2 

n D 2 ⇒ D ≈ 

D − 2 

n √ m



( n 


D) 


n n 

R = m ≥ = T . 

D − 2 D) 

( n 

D) 

( ) n 


D − 2 

R ≥ T ⇒ m ≥ 

( ) ≈ n2 

n D 2 ⇒ D ≈ 

D − 2 

n √ m 

Für AES-128 mit m = 8000 und n = 1600 ergibt sich D = 18.

Komplexität von XL 

Die Komplexität von XL entspricht ( dem Lösen eines ( Linearen ) ω n n 

Gleichungssystems mit T = Variablen, also , 

D) 

D 

wobei ω der Exponent der Lösungsmethode für lineare 

Gleichungssysteme ist (für Gauss-Elimination: ω = 3)


Die Komplexität von XL entspricht ( dem Lösen eines ( Linearen ) ω n n 

Gleichungssystems mit T = Variablen, also , 

D) 

D 

wobei ω der Exponent der Lösungsmethode für lineare 

Gleichungssysteme ist (für Gauss-Elimination: ω = 3) 

Das sieht zwar subexponentiell aus, aber selbst mit der derzeit 

besten bekannten Methode mit ω = 2.3766 ist 

( ) 2.3766 1600 

≈ 2 330 , 

18 

was wesentlich langsamer als ein Brute-Force-Angriff ist.


2002 entdeckt man, dass man XL noch verbessern kann, 

indem man die Dünnbesetztheit des AES-Gleichungssystems 

ausnutzt.




ausnutzt. 

eXtended Sparse Linearisation“ 

”




ausnutzt. 


” 

multiply(X) by Selected monomials and Linearise“ 

”




ausnutzt. 


” 

multiply(X) by Selected monomials and Linearise“ 

” 

Idee: nicht mit allen möglichen Termen vom Grad ≤ D − 2 

multiplizieren, sondern mit einer sorgfältig ausgewählten“ 

” 

Menge an schon existierenden Termen

XSL 

1 Stelle für jede S-Box das zugehörige Gleichungssystem auf. 

2 Wähle Parameter P. Wähle eine ” 

aktive“ S-Box, 

multiplizieren jede Gleichung dieser S-Box mit allen Termen 

von P − 1 ” 

passiven“ S-Boxen und wiederhole das, bis jede 

S-Box genau einmal aktiv war. 

3 Wenn noch nicht genug linear unabhänige Gleichungen 

entstanden sind, wende die sog. T ′ -Methode an. 

4 Linearisierung

T ′ -Methode 

1 Sei T die Menge der Terme in den Gleichungen. Bestimme 

T 1 ′ := {t ∈ T | x 1 · t ∈ T } und T 2 ′ := {t ∈ T | x 2 · t ∈ T } 

2 Stelle das Gleichungssystem so um, dass jede Variable in 

T − T 1 ′ eine Linearkombination von Variablen aus T 1 ′ ist und 

wiederhole das für T 2 ′. 

C 1 := Menge der Gleichungen, die nur aus Termen aus T 1 

′ 

bestehen 

C 2 := Menge der Gleichungen, die nur aus Termen aus T 2 

′ 

bestehen 

3 Multipliziere C 1 mit x 1 und ersetze die Terme durch 

Kombinationen von Termen aus T 2 ′ . Kombiniere diese 

Gleichungen mit C 2 und multipliziere sie mit x 2 

4 Jetzt haben wir mehr linear unabhängige Gleichungen ohne 

die Anzahl der Terme zu erhöhen. Wenn Free < T − 1, wird 

Schritt 3 wiederholt, oder wenn das nicht zum Erfolg führt, 

Schritt 1 mit einer anderen Wahl von T 

i ′ und T 

j ′.

Wie ist P zu wählen? 

Wenn P zu groß gewählt wird, haben wir den 

XL-Algorithmus.



XL-Algorithmus. 

Sei Free( die) 

Anzahl der linear unabhängigen Gleichungen, 

S 

T ≈ t P die Anzahl der Terme und 

P 

( ) S − 1 

T ′ ≈ t ′ t P−1 mit S = Anzahl der im Angriff 

P − 1 

verwendeten S-Boxen und t ′ = |T 1 ′ | (für AES: t′ = 25)






S 


P 

( ) S − 1 


P − 1 

verwendeten S-Boxen und t ′ = |T 1 ′ | (für AES: t′ = 25) 

Dann wird das kleinste P gewählt, so dass 

Free 

T − T ′ ≥ 1






S 


P 

( ) S − 1 


P − 1 

verwendeten S-Boxen und t ′ = |T 1 ′ | (für AES: t′ = 25) 

Dann wird das kleinste P gewählt, so dass 

Free 

T − T ′ ≥ 1 

für AES-128: P = 8 und 

Free 

T −T ′ = 1.005

Komplexität von XSL 

Die Komplexität von XSL ist, wenn die Abschätzungen der 

Autoren über die Anzahl ( linear ) unabhängiger Gleichungen 

ω 

S 

stimmen, T ω = t Pω · . 

P




ω 

S 


P 

Das wird allerdings von einigen Experten angezweifelt.




ω 

S 


P 

Das wird allerdings von einigen Experten angezweifelt. 

Optimistische Schätzungen für AES-128 ergeben T ω ≈ 2 230 , 

besser als XL, aber immernoch schlechter als Brute-Force.




ω 

S 


P 



besser als XL, aber immernoch schlechter als Brute-Force. 

Für AES-256 haben wir P = 8, 

Free 

T −T ′ = 1.006 und T ω ≈ 2 255




ω 

S 


P 





Free 

T −T ′ = 1.006 und T ω ≈ 2 255 

offenes Problem, ob XSL für das AES-System funktioniert




ω 

S 


P 





Free 

T −T ′ = 1.006 und T ω ≈ 2 255 

offenes Problem, ob XSL für das AES-System funktioniert 

kubische Gleichungen: r = 471, t = 697, t ′ = 242, AES-256: 

T ω ≈ 2 195 für ω = 2.3766 und T ω ≈ 2 242 für ω = 3




ω 

S 


P 





Free 

T −T ′ = 1.006 und T ω ≈ 2 255 

offenes Problem, ob XSL für das AES-System funktioniert 

kubische Gleichungen: r = 471, t = 697, t ′ = 242, AES-256: 

T ω ≈ 2 195 für ω = 2.3766 und T ω ≈ 2 242 für ω = 3 

Vincent Rijmen: ” 

The XSL attack is not an attack. It is a 

dream.“

Wird der Traum wahr? 

Fast gleichzeitig zur XSL-Attacke wurde eine Blockchiffre 

(BES), die statt auf 128-Bit-Blöcken auf 128-Byte-Blöcken 

arbeitet, vorgestellt.




arbeitet, vorgestellt. 

BES (Big Encryption System) hat eine noch einfachere und 

elegantere algebraische Struktur als AES.




arbeitet, vorgestellt. 

BES (Big Encryption System) hat eine noch einfachere und 

elegantere algebraische Struktur als AES. 

AES-128 lässt sich so in BES einbetten, dass jede 

AES-Operation einer BES-Operation entspricht bezüglich 

einer Abbildung von 128 Bit auf 128 Byte.

BES 

Bezeichnungen: 

F = GF (2 8 )

BES 


F = GF (2 8 ) 

A = F 16

BES 


F = GF (2 8 ) 

A = F 16 

B = F 128

BES 


F = GF (2 8 ) 

A = F 16 

B = F 128 

B A = Teilmenge von F 128

BES 


F = GF (2 8 ) 

A = F 16 

B = F 128 

B A = Teilmenge von F 128 

Inverses: wie üblich mit 0 −1 = 0 

für Vektor a = (a 0 , . . . , a n−1 ) ∈ F n komponentenweise: 

a −1 = (a0 −1 , . . . , a−1 n−1 )

BES 

Definition 

Die Vektor-Konjugation ã für a ∈ F sei definiert als 

ã = 

(a 20 , a 21 , a 22 , a 23 , a 24 , a 25 , a 26 , a 27)

BES 

Definition 


ã = 

(a 20 , a 21 , a 22 , a 23 , a 24 , a 25 , a 26 , a 27) 

Dafür benutzen wir eine Abbildung φ mit 

ã = φ(a) = 

(a 20 , . . . , a 27)

BES 

Definition 


ã = 

(a 20 , a 21 , a 22 , a 23 , a 24 , a 25 , a 26 , a 27) 


ã = φ(a) = 

(a 20 , . . . , a 27) 

φ lässt sich für n-dim. Vektoren a ∈ F n erweitern: 

ã = φ(a) = (φ(a 0 ), . . . , φ(a n−1 ))

BES 

Definition 


ã = 

(a 20 , a 21 , a 22 , a 23 , a 24 , a 25 , a 26 , a 27) 


ã = φ(a) = 

(a 20 , . . . , a 27) 

φ lässt sich für n-dim. Vektoren a ∈ F n erweitern: 

ã = φ(a) = (φ(a 0 ), . . . , φ(a n−1 )) 

Es gilt: φ(a + a ′ ) = φ(a) + φ(a ′ ) und φ(a −1 ) = φ(a) −1

BES 

Definition 

Wenn jede aufeinanderfolgende Menge von 8 Komponenten in 

a ∈ F 8n von der Form 

(a 20 , a 21 , a 22 , a 23 , a 24 , a 25 , a 26 , a 27) 

ist, hat a die Konjugations-Eigenschaft.

BES 

Definition 



(a 20 , a 21 , a 22 , a 23 , a 24 , a 25 , a 26 , a 27) 

ist, hat a die Konjugations-Eigenschaft. 

Jeder Klartext, Chiffretext, Zustand und Schlüssel für 

AES-128 ist aus A und für BES aus B.

BES 

Definition 



(a 20 , a 21 , a 22 , a 23 , a 24 , a 25 , a 26 , a 27) 



AES-128 ist aus A und für BES aus B. 

B A = φ(A) ⊂ B die AES-Teilmenge von BES

BES 

Definition 



(a 20 , a 21 , a 22 , a 23 , a 24 , a 25 , a 26 , a 27) 



AES-128 ist aus A und für BES aus B. 

B A = φ(A) ⊂ B die AES-Teilmenge von BES 

Jedes Element aus B A erfüllt die Konjugations-Eigenschaft.

BES 

Wir fassen jeden Zustand als Spaltenvektor auf. Für a ∈ A: 

a = 

a 00 a 01 a 02 a 03 

a 10 a 11 a 12 a 13 

a 20 a 21 a 22 a 23 

a 30 a 31 a 32 a 33 

= (a 00 , . . . , a 30 , a 01 , . . . , a 31 , . . . , a 33 ) T 

Für b ∈ B: 

b = (b 000 , . . . , b 007 , b 100 , . . . , b 107 , . . . , . . . , b 330 , . . . , b 337 ) T 

Es gilt: 

φ(a ij ) = (b ij0 , . . . , b ij7 )

BES 

Man kann jede AES-Operation so in BES übertragen, dass bei 

jedem Schritt äquivalente Operationen in B A gemacht werden 

(unter Beibehaltung der Konjugations-Eigenschaft).

BES 

Man kann jede AES-Operation so in BES übertragen, dass bei 

jedem Schritt äquivalente Operationen in B A gemacht werden 

(unter Beibehaltung der Konjugations-Eigenschaft). 

φ 

→ 

A B A 

↓ ↓ 

k → AES BES ← φ(k) 

↓ ↓ 

A 

φ 

← 

B A

BES 

Dabei können wir wieder die Additions-Konstante der S-Box 

in die KeyExpansion packen

BES 


in die KeyExpansion packen 

den linearen Teil der S-Box-Transformation, die ShiftRowsund 

die MixColumns-Transformation zu einer Matrix 

M B ∈ F 128×128 zusammenfassen.

BES 





M B ∈ F 128×128 zusammenfassen. 

Für die letzte Runde bezeichnen wir mit M ∗ B die Matrix M B 

ohne MixColumns.

BES 







ohne MixColumns. 

Round B (b, (k B ) i ) = M B · (b −1 ) + (k B ) i

BES 







ohne MixColumns. 

Round B (b, (k B ) i ) = M B · (b −1 ) + (k B ) i 

Round A (a, (k A ) i ) = φ −1 (Round B (φ(a), φ((k A ) i )))

BES 


p Klartext 

c Chiffretext

BES 


p Klartext 

c Chiffretext 

w i Zustands-Vektor der i-ten Runde vor Inversion 

x i Zustands-Vektor der i-ten Runde nach Inversion

BES 


p Klartext 

c Chiffretext 

w i Zustands-Vektor der i-ten Runde vor Inversion 

x i Zustands-Vektor der i-ten Runde nach Inversion 

k i der i-te Rundenschlüssel

Die Gleichungen für BES 

Für BES ergeben sich folgende Gleichungen: 

w 0 = p ⊕ k 0



w 0 = p ⊕ k 0 

x i = w −1 

i 

für i = 0, . . . , 9



w 0 = p ⊕ k 0 

x i = w −1 

i 

für i = 0, . . . , 9 

w i = M B ⊗ x i−1 ⊕ k i für i = 1, . . . , 9



w 0 = p ⊕ k 0 

x i = w −1 

i 

für i = 0, . . . , 9 

w i = M B ⊗ x i−1 ⊕ k i für i = 1, . . . , 9 

c = M ∗ B ⊗ x 9 ⊕ k 10



w 0 = p ⊕ k 0 

x i = w −1 

i 

für i = 0, . . . , 9 

w i = M B ⊗ x i−1 ⊕ k i für i = 1, . . . , 9 

c = M ∗ B ⊗ x 9 ⊕ k 10 

Betrachten wir die Gleichungen komponentenweise und 

bezeichnen die (8j + m)-te Komponente von x i , w i , k i , p und 

c mit x i,(j,m) , w i,(j,m) , k i,(j,m) , p (j,m) und c (j,m) ,



w 0 = p ⊕ k 0 

x i = w −1 

i 

für i = 0, . . . , 9 

w i = M B ⊗ x i−1 ⊕ k i für i = 1, . . . , 9 

c = M ∗ B ⊗ x 9 ⊕ k 10 



c mit x i,(j,m) , w i,(j,m) , k i,(j,m) , p (j,m) und c (j,m) , 

addieren bzw. multiplizieren die linken Seiten rüber



w 0 = p ⊕ k 0 

x i = w −1 

i 

für i = 0, . . . , 9 

w i = M B ⊗ x i−1 ⊕ k i für i = 1, . . . , 9 

c = M ∗ B ⊗ x 9 ⊕ k 10 



c mit x i,(j,m) , w i,(j,m) , k i,(j,m) , p (j,m) und c (j,m) , 

addieren bzw. multiplizieren die linken Seiten rüber 

und bezeichnen M B mit (α) und MB ∗ mit (β), erhalten wir für 

j = 0, . . . , 15 und m = 0, . . . , 7:


0 = w 0,(j,m) ⊕ p (j,m) ⊕ k 0,(j,m) 

0 = x i,(j,m) ⊗ w i,(j,m) ⊕ 1 für i = 0, . . . , 9 

0 = w i,(j,m) ⊕ k i,(j,m) ⊕ ∑ 

α (j,m),(j ′ ,m ′ ) ⊗ x i−1,(j ′ ,m ′ ) 

(j ′ ,m ′ ) 

für i = 1, . . . , 9 

0 = c (j,m) ⊕ k 10,(j,m) ⊕ ∑ 

(j ′ ,m ′ ) 

β (j,m),(j ′ ,m ′ ) ⊗ x 9,(j ′ ,m ′ )


2688 Gleichungen (1280 quadratische und 1408 lineare)


2688 Gleichungen (1280 quadratische und 1408 lineare) 

5248 Terme (aus 2560 Zustands- und 1408 Schlüsselvariablen)


2688 Gleichungen (1280 quadratische und 1408 lineare) 

5248 Terme (aus 2560 Zustands- und 1408 Schlüsselvariablen) 

Aus der Konjugations-Eigenschaft erhalten wir noch weitere 

multivariate quadratische Gleichungen: 

0 = w 0,(j,m) ⊕ p (j,m) ⊕ k 0,(j,m) 

0 = w i,(j,m) ⊕ k i,(j,m) ⊕ ∑ 

α (j,m),(j ′ ,m ′ ) ⊗ x i−1,(j ′ ,m ′ ) 

(j ′ ,m ′ ) 

für i = 1, . . . , 9 

0 = c (j,m) ⊕ k 10,(j,m) ⊕ ∑ 

(j ′ ,m ′ ) 

β (j,m),(j ′ ,m ′ ) ⊗ x 9,(j ′ ,m ′ ) 

0 = x i,(j,m) ⊗ w i,(j,m) ⊕ 1 für i = 0, . . . , 9 

0 = x 2 i,(j,m) ⊕ x i,(j,m+1) für i = 0, . . . , 9 

0 = w 2 i,(j,m) ⊕ w i,(j,m+1) für i = 0, . . . , 9

Die Gleichungen für BES, Komplexität 

komplette AES-Verschlüsselung: 5248 Gleichungen über F 

(3840 quadratische und 1408 lineare) aus 7808 Termen



(3840 quadratische und 1408 lineare) aus 7808 Termen 

KeyExpansion: zusätzlich 2560 Gleichungen (960 quadratische 

und 1600 lineare) aus 2368 Termen





und 1600 lineare) aus 2368 Termen 

Das GF (2 8 )-System ist viel einfacher als das GF (2)-System 

aus dem vorigen Abschnitt.







aus dem vorigen Abschnitt. 

Wenn die Abschätzungen für die XSL-Komplexität stimmen, 

wird erwartet, dass man das









wird erwartet, dass man das GF (2 8 )-System mit nur 2 100 

AES-Verschlüsselungen lösen kann, was erheblich schneller als 

Brute-Force wäre.









wird erwartet, dass man das GF (2 8 )-System mit nur 2 100 

AES-Verschlüsselungen lösen kann, was erheblich schneller als 

Brute-Force wäre. 

leider immernoch zu aufwendig, um es praktisch zu 

implementieren :-(

Vielen Dank! 

Noch Fragen?

Advanced Encryption Standard Rijndael

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?