Übersicht. Geschichte Mathematische Grundlagen Algorithmus. ISM WS 2017/18 Teil 6/AES

Transkript

1 Übersicht Geschichte Mathematische Grundlagen Algorithmus 2

2 Literatur [6-1] [6-2] [6-3] [6-4] [6-5] [6-6] nen/technischerichtlinien/tr02102/bsi-tr pdf [6-7] Testdaten: encryption/55-aes-test-vectors#aes-ecb [6-8] [6-9] 3 Geschichte I 1997: Öffentliche Ausschreibung Symmetrische Verschlüsselung Mindestblocklänge 128 Bit Schlüssellängen 128, 192 und 256 Bit Weltweit keine Lizenzgebühren Nutzbar für 30 Jahre 2000: Entscheidungsprozess in mehreren Runden 2002: Definition als Standard Die mit * gekennzeichneten Abbildungen stammen aus dem Standard [6-1]. Dies gilt auch für viele Beispiele. 4

3 Geschichte II - Endrunde Name Land Organisation MARS USA IBM RC6 USA RSA Laboratories RIJNDAEL Belgien J. Daeman, V. Rijmen SERPENT GB, Norwegen, Israel R. Anderson, E. Biham, L. Knudsen TWOFISH USA B. Schneier et al. Die Entscheidung fiel zugunsten RIJNDAEL. Alle 5 Endrundenkandidaten sind gute Chiffre-Algorithmen. 5 Advanced Encryption Standard (AES) Entwickler: Joan Daemen, Vincent Rijmen (Belgien), 2002 Symmetrisches Verfahren Blocklänge 128 bit (16 byte) Schlüssellänge 128 bit, 192 bit oder 256 bit Ver- und Entschlüsselung verläuft in Runden, deren Anzahl von der Länge des Schlüssels abhängig ist: Schlüssellänge 128 bit: 10 Runden (N r ) Schlüssellänge 192 bit: 12 Runden (N r ) Schlüssellänge 256 bit: 14 Runden (N r ) Primär beziehen sich die Folien auf die Schlüssellänge 128 bit, an einigen Stellen werden aber auch Verallgemeinerungen benutzt. 6

4 Mathematische Grundlagen I AES beruht auf einem endlichen Körper GF(256) bzw. GF(2 8 ) über Polynome vom max. Grad 7. Es gilt: Der Körper für die Koeffizienten ist Z 2. GF(256) kann also auch geschrieben werden: Z 2 [x] m(x) Das irreduzible Polynom m(x) ist m(x) x 8 +x 4 +x 3 +x+1. Das irreduzible Polynom m(x) muss vom Grad 8 sein warum? Da es sich um einem Körper handelt, gibt es zu jeder Operation eine inverse, was bei der Entschlüsselung ausgenutzt wird. 7 Mathematische Grundlagen II Die 8 Koeffizienten aus Z 2 werden durch ein Byte repräsentiert: p(x) = a 7 x 7 +a 6 x 6 +a 5 x 5 +a 4 x 4 +a 3 x 3 +a 2 x 2 +a 1 x+a 0 Byte = a 7 a 6 a 5 a 4 a 3 a 2 a 1 a 0 Bis auf wenige Ausnahmen wird beim AES mit Bytes gearbeitet, wobei jedes Byte einem Polynom entspricht. 8

5 Mathematische Grundlagen III Addition und Subtraktion werden durch XOR implementiert, da die Koeffizienten aus Z 2 kommen: Operator definiert durch e=0 Operator wird durch XOR realisiert. Addition und Subtraktion sind gleich. Operator definiert durch Operator wird durch AND realisiert. e=1 9 Mathematische Grundlagen IV - Multiplikation Modul m(x) ist x 8 +x 4 +x 3 +x+1 oder 0x11b Beispiel aus [*, S.11]: (x 6 + x 4 + x 2 +x + 1)*(x 7 + x + 1) = x 13 + x 11 + x 9 + x 8 + x 6 + x 5 + x 4 + x (x 13 +x 11 +x 9 +x 8 +x 6 +x 5 +x 4 +x 3 +1) mod (x 8 +x 4 +x 3 +x+1) = x 7 +x 6 +1 Also Ausmultiplizieren und dann durch Division den Rest bestimmen Als Bitsequenzen in Hex: 0x57 * 0x83 = 0xC1 10

6 Mathematische Grundlagen V - Multiplikation Wenn ein Polynom mit x multipliziert wird, dann ist das ein Schieben um 1 Stelle nach links in der Bitstring-Repräsentation. Multiplikation Ergebnis Ergebnis in Bits mit Korrektur 0x57*0x01 0x x57*0x02 0xAE x57*0x04 0x x57*0x08 0x8E x57*0x10 0x x57*0x20 0x0E x57*0x40 0x1C x57*0x80 0x Korrektur durch m(x) Das ist die Modulo- Operation Tabelle mit mehrfachen Multiplizieren von 0x57 mit x Bitte beachten: x = 1*x 1 +0*x 0 = 0x02. Die 0x57 kommt aus dem vorherigen Beispiel. 11 Mathematische Grundlagen VI - Multiplikation xtimes(byte b) { if b[7] { // falls Bit 7 auf 1 ist return (b<<1) XOR 0x1b else { return (b<<1) Korrektur durch m(x)= 0x11b Durch den Linksshift << fällt das vorderste Bit eines Bytes immer heraus. Die Routine xtimes() multipliziert ein Polynom mit x. 12

7 Mathematische Grundlagen VII - Multiplikation (x 6 + x 4 + x 2 +x + 1)*(x 7 + x + 1) = 0x57 * 0x83 0x57*(0x80+0x02+0x01) = 0x57*0x80 + 0x57*0x02 + 0x57*0x01 = 0x38 + 0xAE + 0x57 In Hex Werte aus der Tabelle ablesen 0x38 = xAE = Addieren durch XOR x57 = Addieren durch XOR (= 0xC1 = x 7 +x 6 +1) Der Algorithmus zur Multiplikation zweier Polynome ist damit sehr dem Algorithmus der schnellen Potenzierung ähnlich, nur dass nun mit x multipliziert und nicht quadriert wird. 13 Mathematische Grundlagen VIII Das Inverse Das multiplikative Inverse lässt sich mit dem erweiterten Euklid'schen Algorithmus bestimmen. p(x) * p -1 (x) 1 (mod m(x)) Es wird daher der ggt berechnet und damit bestimmt: ggt(p(x),m(x))= 1 p'(x)*p(x)+m'(x)*m(x) (mod m(x)) p -1 (x) p'(x) (mod m(x)) Der Euklid'sche Algorithmus benutzt dann die Subtraktion, die in Z 2 gleich der Addition (XOR) ist. Wir verlassen nun die mathematische Sichtweise und gehen zur Sicht der Informatik über: Fast alle Bit-Operationen auf Bytes beruhen auf diesen mathematischen Zusammenhängen. 14

8 Repräsentation der Blöcke - state Datenblock (State) a 0,0 a 0,1 a 0,2 a 0,3 Blocklänge= 32*N b Bits, N b =4 a 1,0 a 1,1 a 1,2 a 1,3 a 2,0 a 2,1 a 2,2 a 2,3 a 3,0 a 3,1 a 3,2 a 3,3 16 byte = 128 bit Die Tabelle wird im Originaldokument [*] state genannt. Jeder einzelne Schritt in AES verarbeitet ein state und liefert ein neues state. In AES sind diese 16 byte die einzige Blockgröße; RIJNDAEL erlaubt noch zwei weitere Blockgrößen, die aber nicht in AES übernommen wurden; daher ist N b im AES immer Repräsentation der Blöcke I/O Eine Sequenz von Eingabe-Bytes in 0, in 1, in 2,,in 15 wird spaltenweise das state-array eingelesen. Schema: s[r,c]:= in [r+4*c] mit r in 0..3 und c in 0..3 Analog wird das state-array bei der Ausgabe spaltenweise in die Byte-Sequenz out 0, out 1, out 2,,out 15 konvertiert. Schema: out [r+4*c] := s[r,c] mit r in 0..3 und c in 0..3 r und c durchlaufen ihre Werte aufsteigend, wobei r schneller als c läuft. Aus [*] 16

9 Der Algorithmus im Überblick (Verschlüsselung) PROC encryptaes(state, ChipherKey) { KeyExpansion(ChipherKey, ExpandedKey); AddRoundKey(state, ExpandedKey[0]); for (i = 1; i < N r ; i++) do Round(state, ExpandedKey[i]); od FinalRound(state, ExpandedKey[N r ]); Werte für N r : 128 bit: 10 Runden 192 bit: 12 Runden 256 bit: 14 Runden PROC Round(state, ExpandedKey) { SubBytes(state); ShiftRows(state); MixColumns(state); AddRoundKey(state, ExpandedKey); PROC FinalRound(state, ExpandedKey) { SubBytes(state); ShiftRows(state); AddRoundKey(state, ExpandedKey); MixColumns() fehlt 17 Bemerkungen Vor Beginn der Verschlüsselung (und vor der Entschlüsselung) wird aus dem geheimen Schlüssel ein Array von expandierten Schlüsseln mit N r +1 Elementen gemacht. N r ist die Anzahl der Runden. Jedes Array-Element von ExpandedKey[] enthält einen Teilschlüssel, der in einer bestimmten Runde benutzt wird. 18

10 AddRoundKey(state, ExpandedKey[...]); I KeyExpansion(ChipherKey,ExpandedKey); AddRoundKey(state, ExpandedKey[0]); for... do SubBytes(state); ShiftRows(state); MixColumns(state); AddRoundKey(state, ExpandedKey); od Datenblock (state) a 0,0 a 0,1 a 0,2 a 0,3 a 1,0 a 1,1 a 1,2 a 1,3 a 2,0 a 2,1 a 2,2 a 2,3 a 3,0 a 3,1 a 3,2 a 3,3 16 byte = 128 bit Rundenschlüssel k 0,0 k 0,1 k 0,2 k 0,3 k 1,0 k 1,1 k 1,2 k 1,3 = k 2,0 k 2,1 k 2,2 k 2,3 k 3,0 k 3,1 k 3,2 k 3,3 Datenblock (state) b 0,0 b 0,1 b 0,2 b 0,3 b 1,0 b 1,1 b 1,2 b 1,3 b 2,0 b 2,1 b 2,2 b 2,3 b 3,0 b 3,1 b 3,2 b 3,3 Es handelt sich um eine einfache blockweise XOR-Verknüpfung (also um eine Addition in GF(256)). 19 AddRoundKey(state, ExpandedKey[...]); II Datenblock (state) Rundenschlüssel Datenblock (state) a 0,0 k 0,0 b 0,0 a 1,0 a 2,0 k 1,0 = k 2,0 b 1,0 b 2,0 Dies wird 4x durchgeführt. a 3,0 k 3,0 b 3,0 a 0,0 a 1,0 a 2,0 a 3,0 Eine Spalte des state wird Word (32 bit) genannt. Die Blocklänge wird in Worten definiert, hier 4. 20

11 SubBytes(state) I KeyExpansion(ChipherKey,ExpandedKey); AddRoundKey(state, ExpandedKey[0]); for... do SubBytes(state); ShiftRows(state); MixColumns(state); AddRoundKey(state, ExpandedKey); od Hinweis: Die S-Box wird auch zur Generierung der Rundenschlüssel verwendet. Datenblock (state) a 0,0 a 0,1 a 0,2 a 0,3 S-Box Datenblock (state) b 0,0 b 0,1 b 0,2 b 0,3 a 1,0 a 1,1 a 1,2 a 1,3 b 1,0 b 1,1 b 1,2 b 1,3 a 2,0 a 2,1 a 2,2 a 2,3 b 2,0 b 2,1 b 2,2 b 2,3 a 3,0 a 3,1 a 3,2 a 3,3 b 3,0 b 3,1 b 3,2 b 3,3 S-Box steht für Substitutionsbox: sie dient dem "Verwürfeln" der Information. S-Boxen werden meist durch Tabellen realisiert, die den Ersetzungsmechanismus definieren. 21 SubBytes(state) II Da die S-Box unabhängig von den Schlüsseln ist, kann sie vorher berechnet und in einer Tabelle gespeichert werden: Aus 0x85 wird 0x97 Aus [*] Für die Entschlüsselung gibt es eine "inverse" S-Box. Die Werte können aus einem Array geholt, oder live in einer Funktion berechnet werden (je nach Speicherbedarf). 22

12 SubBytes(state) III Berechnung der S-Box Der Inhalt dieser Tabelle lässt sich anhand folgender Formel berechnen: y:= A*x -1 c x ist das Originalbyte, dessen Inverses in GF(256) mit einer Matrix A multipliziert wird, dessen Ergebnis am Ende zu einer Konstanten c addiert wird. Das Ergebnis ist ein neues Byte. Es wird also das multiplikative Inverse Element mittels des erweiterten Euklid'schen Algorithmus berechnet, wobei 0 sein eigenes Inverses ist. Dann wird das Ergebnis in GF(2) bzw. Z 2, also per XOR transformiert nach folgender Formel: b i = b i b (i+4)mod 8 b (i+5)mod 8 b (i+6)mod 8 b (i+7)mod 8 c i wobei i die Bitnummer (0 bis 7) und c eine Konstante mit dem Wert 0x63 ist. 23 ShiftRows(state) I KeyExpansion(ChipherKey,ExpandedKey); AddRoundKey(state, ExpandedKey[0]); for... do SubBytes(state); ShiftRows(state); MixColumns(state); AddRoundKey(state, ExpandedKey); od Die einzelnen Zeilen werden in Abhängigkeit der Zeilennummer zyklisch nach links geschoben. Kein Shift 1x Shift 2x Shift 3x Shift Aus [10-1] 24

13 MixColumns(state) I KeyExpansion(ChipherKey,ExpandedKey); AddRoundKey(state, ExpandedKey[0]); for... do SubBytes(state); ShiftRows(state); MixColumns(state); AddRoundKey(state, ExpandedKey); od Aus [*] Hier werden die Bytes innerhalb einer Spalte "verschoben" und dabei umgerechnet. Diese Funktion bestimmt wesentlich die kryptographische Stärke von AES. 25 Bemerkungen SubBytes() tauscht lediglich ein Byte gegen ein anderes aus, d.h. es gibt keine Effekte von einem Wert eines Bytes auf ein anderes, alle Bytes werden dabei isoliert behandelt. MixCollumns() sorgt dafür, dass in einer Spalte benachbarte Bytewerte sich gegenseitig beeinflussen, so dass sich bestimmte Werte auf andere im Status auswirken. Durch das in einer späteren Runde durchgeführte Shiften werden die Wirkungen innerhalb einer Spalte auf andere Spalten verteilt. Machen Sie sich die geniale Kombination von SubBytes(), ShiftRows() und MixCollumns() klar. 26

14 MixColumns(state) II Datenblock (state) Datenblock (state) a 0,0 a 0,1 a 0,2 a 0,3 b 0,0 b 0,1 b 0,2 b 0,3 a 1,0 a 1,1 a 1,2 a 1,3 b 1,0 b 1,1 b 1,2 b 1,3 a 2,0 a 2,1 a 2,2 a 2,3 b 2,0 b 2,1 b 2,2 b 2,3 a 3,0 a 3,1 a 3,2 a 3,3 b 3,0 b 3,1 b 3,2 b 3,3 Dazu wird jede Spalte als ein Polynom vom Grad 3, dessen Koeffizienten die Bytes a *,* sind, aufgefasst: c(x) = a 0,0 +a 1,0 *x+a 2,0 *x 2 +a 3,0 *x 3 Achtung! Hier sind nun die Koeffizienten selbst Polynome, d.h. die Arithmetik dieser Zahlen ist die von GF(256), Dieses Polynom wird mit f(x) = 3x 3 +x 2 +x+2 multipliziert und davon der Rest mit mod x 4-1 bestimmt. 27 MixColumns(state) III Das Ganze noch einmal in äquivalenter Form eher zum Programmieren: Es werden die Originalbytes mit den Konstanten 1, 2 oder 3 innerhalb von GF(256) multipliziert. Diese Zwischenergebnisse werden dann in folgender Weise addiert: b 0 = (a 0 2) (a 1 3) (a 2 1) (a 3 1) b 1 = (a 0 1) (a 1 2) (a 2 3) (a 3 1) b 2 = (a 0 1) (a 1 1) (a 2 2) (a 3 3) b 3 = (a 0 3) (a 1 1) (a 2 1) (a 3 2) a 0,0 b 0,0 a 1,0 b 1,0 a 2,0 b 2,0 a 3,0 b 3,0 28

15 KeyExpansion(ChipherKey, ExpandedKey) I KeyExpansion(ChipherKey,ExpandedKey); AddRoundKey(state, ExpandedKey[0]); for... do SubBytes(state); ShiftRows(state); MixColumns(state); AddRoundKey(state, ExpandedKey); od Rundenschlüssel (4x32 bit = 128 bit) k 0,0 k 0,1 k 0,2 k 0,3 k 1,0 k 1,1 k 1,2 k 1,3 k 2,0 k 2,1 k 2,2 k 2,3 k 3,0 k 3,1 k 3,2 k 3,3 Die Schlüssellänge ist variabel: 128= 32*4, 192= 32*6, 256= 32*8, also N k = 4, 6 oder 8 N k ist die Anzahl der Worte des Schlüssels. Für jede Runde muss ein eigener Schlüssel generiert werden, der genauso groß wie state ist, also 128 bit. Es gibt drei Anzahlen von Runden: N r =10, 12, 14 Runden. AddRoundKey() wird N r +1 mal aufgerufen, d.h. für 128 bit sind 11 Rundenschlüssel erforderlich. Der erste Rundenschlüssel ist immer der Originalschlüssel, d.h. es müssen daraus 10 weitere Schlüssel generiert werden (bei 128 bit). 29 KeyExpansion(ChipherKey, ExpandedKey) II Schlüsseltabelle (ExpandedKey) 128 bit-schlüssel (4x32 bit) k 0,0 k 0,1 k 0,2 k 0,3 k 0,4 k 0,5 k 0,6 k 1,0 k 1,1 k 1,2 k 1,3 k 1,4 k 1,5 k 1,6 k 2,0 k 2,1 k 2,2 k 2,3 k 2,4 k 2,5 k 2,6 k 3,0 k 3,1 k 3,2 k 3,3 k 3,4 k 3,5 k 3,6 4x15 Worte 256 bit Spalte=Wort (32 bit) 4x13 Worte 4x11 Worte Word 192 bit 128 bit Die Spalten sind jeweils die Worte, die als Grundlage zur Berechnung der nächsten Worte dienen. Die Schlüsseltabelle wird dazu als ein Vektor von Worten aufgefasst; dieser wird nun W genannt. W[0] ist damit die 1. Spalte, W[1] die 2. Spalte etc. in der Abbildung oben. Die Werte 11, 13 und 15 bilden die Anzahl der Rundenschlüssel. 30

16 KeyExpansion(ChipherKey, ExpandedKey) III Schlüssellänge N k N r 128 bit 4 10 Das ist die Version für die Schlüssellänge von 128 bit: 192 bit bit 8 14 FUNC keyexpansion128(key) { Kopieren des Schlüssels nach W[0..3] for i:=4 to 40 { temp:= W[i-1] // das vorherige Wort wird geholt if (i mod 4) = 0 { temp:= SubWord(RotWord(temp)) XOR rcon[i/4] W[i]:= W[i-4] XOR temp return W 31 KeyExpansion(ChipherKey, ExpandedKey) IV Das ist allgemeine Version für alle Schlüssellängen: FUNC keyexpansion(key) { Kopieren des Schlüssels nach W[0..N k -1] for i:=n k to 4*N r { temp:= W[i-1] // das vorherige Wort wird geholt if (i mod N k ) = 0 { temp:= SubWord(RotWord(temp)) XOR rcon[i/n k ] else { if (N k = 8) AND (i mod N k ) = 4 { temp:= SubWord(temp) W[i]:= W[i-N k ] XOR temp return W 32

17 Bemerkungen Die ersten N k Worte sind der originale Schlüssel; alle anderen Worte werden iterativ in Bezug auf die davor liegenden Worte innerhalb des Arrays berechnet. Die Funktion SubWord() macht dasselbe wie SubBytes(), d.h. ersetzen der Bytes des Wortes anhand der S-Box. Die Funktion RotWord() verschiebt das Array von Bytes, das ein Wort bildet zirkulär nach Links. Also aus [a 0,a 1,a 2,a 3 ] wird [a 1,a 2,a 3,a 0 ], wobei [] die Byte-Sequenz innerhalb des Wortes bedeutet. rcon[] ist ein Array von Konstanten; die Division (i/n k ) ist immer ganzzahlig, da (i mod N k )=0 gilt. rcon[0] wird nie benutzt. 33 rcon[] Das Array rcon[] spiegelt die Werte folgender Funktion wieder: rcon(i)= x i-1 mod x 8 +x 4 +x 3 +x+1 Da auch hier der Schlüssel nicht eingeht, können die Werte wie bei der S-Box im voraus berechnet und und in einer Tabelle gehalten werden. Die Werte sind: i rcon(i) i rcon(i) i rcon(i) i rcon(i) 0 0x8D 4 0x08 8 0x xD8 1 0x01 5 0x10 9 0x1B 13 0xAB 2 0x02 6 0x x x4D 3 0x04 7 0x x6C 15 0x9A Es ist auch möglich, die Werte live zu berechnen. Die dazu erforderlichen Algorithmen sind oben angegeben. Dies ist bei Prozessoren mit sehr kleinem RAM/ROM notwendig. 34

18 Entschlüsselung I PROC encryptaes(state, ChipherKey) { Invert_KeyExpansion(ChipherKey, ExpandedKey); AddRoundKey(state, ExpandedKey[N r ]); for (i = N r -1; i >= 1 ; i--) do Invert_Round(state, ExpandedKey[i]); od Invert_FinalRound(state, ExpandedKey[0]); PROC Invert_Round(state, ExpandedKey) { Invert_ShiftRows(state); Invert_SubBytes(state); AddRoundKey(state, ExpandedKey); Invert_MixColumns(state); PROC Invert_FinalRound(state, ExpandedKey) { Invert_ShiftRows(state); Invert_SubBytes(state); AddRoundKey(state, ExpandedKey); Ähnliche Struktur, aber mit einer anderen S-Box, das Verschieben verläuft auch in die andere Richtung und die Anwendung der Teilschlüssel ist umgekehrt. Siehe dazu: [*] Kap Kritik am AES Zu wenige Runden; der Puffer gegenüber schneller Hardware ist zu gering aber noch geht es. Für Mathematiker zu einfach besseres Gefühl bei komplexen Algorithmen :-) Hier noch etwas zum Lesen: [A] [B] 36

19 Nach dieser Anstrengung etwas Entspannung... 37