Kriptográfia és Információbiztonság 4. előadás Sapientia Egyetem, Műszaki és Humántudományok Tanszék Marosvásárhely, Románia mgyongyi@ms.sapientia.ro 2015
Miről volt szó az elmúlt előadáson? blokk-titkosító rendszerek, DES (Data Encryption Standard), tervezési szempontok, biztonság, támadási módszerek, 3DES, 2DES, XDES, blokk-titkosítási módok (ECB, CBC, CFB, OFB, CTR).
Miről lesz szó? Számelméleti alapfogalmak: az euklideszi algoritmus és változatai Véges testek aritmetikája AES (Advanced Encryption Standard) kör-kulcs generálás, titkosítás, visszafejtés, implementáció.
Számelméleti alapfogalmak Az euklideszi algoritmus egyike a legrégebbi, napjainkban is alkalmazott eljárásoknak: két egész szám legnagyobb közös osztóját határozza meg. Az a és b egész számok legnagyobb közös osztója, az a legnagyobb szám amely osztja az a-t és b-t is. Jelölése: lnko(a, b), (a, b), vagy gcd(a, b). Az a és b egész számok legnagyobb közös osztója az a d legkisebb egész szám, amely egyenlő az a és b lineáris kombinációjával: d = x a + y b, ahol x, y egész számok. Az a és b egész számok relatív prímek, ha lnko(a, b) = 1. Például: lnko(101, 64) = 1 64 és 101 relatív prímek. Feĺırható: 101 ( 19) + 64 30 = 1. Például: lnko(64, 52) = 4 64 és 52 nem relatív prímek. Feĺırható: 64 ( 4) + 52 5 = 4.
Az euklidészi algoritmus és változatai Euklidész algoritmusa: legyenek r 0 = a és r 1 = b egész számok, úgy hogy a b > 0. Ha az osztási algoritmust egymás után többször alkalmazzuk, akkor a következő számsorozatot kapjuk: r 0, r 1,..., r n, r n+1, ahol r j = r j+1 q j+1 + r j+2, 0 < r j+2 < r j+1, j {0, 1,..., n 2} és r n+1 = 0. Ekkor lnko(a, b) = r n. Euklidész kiterjesztett algoritmusa: legyenek a, b pozitív egész számok, akkor feĺırható a következő összefüggés: lnko(a, b) = x n a + y n b, n {0, 1, 2,... }, ahol x n és y n a következő rekurzív számítási sorozat n-ik tagjai: x 0 = 1, y 0 = 0 x 1 = 0, y 1 = 1 x j = x j 2 q j 1 x j 1 y j = y j 1 q j 1 y j 1, ahol q j a megfelelő hányados, amelyet az euklidészi algoritmus során számolunk ki.
A kiterjesztett euklidészi algoritmus, példa Határozzuk meg 84 és 35 legnagyobb közös osztóját, majd azokat az x és y egész számokat, melyekre fennáll a következő összefüggés: 84 x + 35 y = d, ahol d = lnko(84, 35). a b r q x 0 x 1 y 0 y 1 1 0 0 1 84 35 14 2 0 1 1 2 35 14 7 2 1 2 2 5 14 7 0 2 Tehát a megoldás: d = 7, x = 2, y = 5, és fennáll a következő összefüggés: 84 ( 2) + 35 5 = 7.
A kiterjesztett euklidészi algoritmus, példa Határozzuk meg 45 és 31 legnagyobb közös osztóját, majd azokat az x és y egész számokat, melyekre fennáll a következő összefüggés: 45 x + 31 y = d, ahol d = lnko(45, 31). v a b r q x 0 x 1 y 0 y 1 1 0 0 1 45 31 14 1 0 1 1 1 31 14 3 2 1 2 1 3 14 3 2 4 2 9 3 13 3 2 1 1 9 11 13 16 2 1 0 2 Tehát a megoldás: d = 1, x = 11, y = 29, és fennáll a következő összefüggés: 45 ( 11) + 31 16 = 1.
A kiterjesztett euklidészi algoritmus Az algoritmus bemenete az a és b egész számok, kimenete pedig a d, x, y számok amelyekre fennáll: d = a x + b y. exteuclid (a, b): x0, x1, y0, y1 = 1, 0, 0, 1 while True: r = a % b if r == 0: d, x, y = b, x1, y1 return (d, x, y) q = a / b a = b b = r x = x0 - q * x1 y = y0 - q * y1 x0, x1, y0, y1 = x1, x, y1, y
Moduláris inverz meghatározása Az a x 1 (mod m) kongruenciának a megoldását, ahol lnko(a, m) = 1 az a inverzének hívjuk (mod m) szerint és a 1 -el, vagy 1 -val jelöljük. a A kongruencia megoldhatósági feltétele az, hogy lnko(a, m) = 1. Példa: 17 inverze mod 27 szerint 8, mert fennáll: 17 8 = 1 (mod 27). A moduláris inverz meghatározásához a kiterjesztett euklideszi algoritmust használjuk, mert a kongruencia átírható 1 = a x + m y alakba. Ebben az esetben az x az a inverze lesz invmod (a, m): (d, x, y ) = exteuclid (a, b) if (d!= 1) error "inverse undefined" if (x < 0) return x + m else return x (mod m) szerint.
Véges-testek aritmetikája Az AES esetében olyan halmazt jelent, amelyben benne vannak a bináris együtthatójú, n 1 fokszámnál kisebb polinomok: f (x) = a n 1x n 1 + a n 2x n 2 + + a 1x + a 0. egy GF (2 n ) feletti polinom egyedi módon, az együtthatók segítségével leírható, n biten: (a n 1a n 2... a 0). Példa x 6 + x 3 + x -nek megfelelő bináris alak: 0100 1010. n-ed fokú irreducibilis polinom: olyan polinom, amely nem bontható fel két n-nél kisebb fokú polinom szorzatára. A műveleteket a szabályos polinomok feletti műveleti szabályok szerint kell végezni, ahol az együtthatók esetében (mod 2) kell számolni. Ha egy művelet elvégzése után nagyobb kitevőt kapunk mint x n 1, akkor meg kell határozni az eredmény m(x) szerinti osztási maradékát, ahol m(x) egy n-ed fokú irreducibilis polinom.
Véges-testek aritmetikája Ha n = 3, akkor összesen 2 3 különböző polinom szerkeszthető: 0, 1, x, x + 1, x 2, x 2 + 1, x 2 + x, x 2 + x + 1. GF (2 3 )-ban két irreducibilis polinom van: x 3 + x 2 + 1, x 3 + x + 1. Az alkalmazott műveleteket könnyű implementálni: Az összeadás megfelel a műveletnek. A szorzás visszavezethető az x és hatványaival való szorzásra, ami egy balra shift és egy feltételhez kötött konstanssal való művelet elvégzését jelenti. Az alkalmazott technika a következőn alapszik: x n (mod m(x)) = m(x) x n. A kivonás ekvivalens az összeadással, mert 1 + 1 = 1 1 = 0, 1 0 = 1 + 0 = 1, 0 + 1 = 0 1 = 1, 0 + 0 = 0 0 = 0. Az osztáshoz multiplikatív inverzre van szükség, amelyet egy adott irreducibilis polinom szerint kell meghatározni, ez kiterjesztett Euklideszi algoritmussal határozható meg.
Véges-testek aritmetikája Példa, összeadás: (x + 1) + x = 2 x + 1 = 1, (011) (010) = 001 Példa, szorzás, m(x) = x 3 + x 2 + 1 szerint: (x 2 + x) (x + 1) = x 2 + x + 1, mert (x 2 + x) (x + 1) = x 3 + x 2 + x 2 + x = x 3 + x, ahol az m(x) = x 3 + x 2 + 1 szerinti osztási maradék x 2 + x + 1. Példa, szorzásra, 8 biten (mod m(x)) szerint: legyen f (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. meghatározzuk: x f (x) = (a 7 x 8 + a 6 x 7 + a 5 x 6 + a 4 x 5 + a 3 x 4 + a 2 x 3 + a 1 x 2 + a 0 x) (mod m(x)). megállapítható: x f (x) = { (a6a 5a 4a 3a 2a 1a 00), ha a 7 = 0 (a 6a 5a 4a 3a 2a 1a 00) (m(x) x 8 ), ha a 7 = 1
Véges-testek aritmetikája Határozzuk meg (x 6 + x 3 + x 2 + 1) (x 7 + x 2 + 1) szorzatot m(x) = x 8 + x 4 + x 3 + x + 1 szerint. Binárisan ez azt jelenti, hogy mennyi: (01001101) (10000101)? tehát: (01001101) (00000001) = (01001101) (01001101) (00000010) = (10011010) (01001101) (00000100) = (00110100) (00011011) = (00101111) (01001101) (00001000) = (01011110) (01001101) (00010000) = (10111100) (01001101) (00100000) = (01111000) (00011011) = (01100011) (01001101) (01000000) = (11000110) (01001101) (10000000) = (10001100) (00011011) = (10010111) (01001101) (10000101) = (01001101) [(00000001) (00000100) (10000000)] = (01001101) (00101111) (10010111) = (11110101) ami megfelel: x 7 + x 6 + x 5 + x 4 + x 2 + 1-nek.
A kiterjesztett euklidészi algoritmus Az euklidészi algoritmus, a kiterjesztett euklideszi algoritmus alkalmazható a polinomok körében is a legnagyobb közös osztó, illetve a multiplikatív inverz meghatározására. Azt mondjuk, hogy a d(x) polinom az a(x) és b(x) polinomok legnagyobb közös osztója, ha fennáll, hogy d(x) a legnagyobb olyan fokszámú polinom amelyik osztja a(x)-t és b(x)-et is. az euklideszi algoritmus szerint feĺırható: lnko[a(x), b(x)] = lnko[b(x), a(x) (mod b(x))]. Pl: lnko(x 6 + x 5 + x 4 + x 2 + x + 1, x 5 + x 4 + x 3 + x 2 + x + 1) = x 3 + 1. x 6 + x 3 + x multiplikatív inverze, (mod x 8 + x 4 + x 3 + x + 1) szerint: x 7 + x 5 + x 3 + x + 1, mert (x 6 + x 3 + x) (x 7 + x 5 + x 3 + x + 1) = 1 (mod x 8 + x 4 + x 3 + x + 1).
A kiterjesztett euklidészi algoritmus, példa Határozzuk meg a(x) = x 8 + x 4 + x 3 + x + 1 és b(x) = x 6 + x 3 + x legnagyobb közös osztóját, majd azokat az v(x) és u(x) polinomokat, amelyekre fennáll a következő összefüggés: a(x) v(x) + b(x) u(x) = 1. a b q r x 0 x 1 y 0 y 1 1 0 0 1 x 8 + x 4 + x 6 + x 2 x 5 + x 4 + 0 1 1 x 2 x 3 + x + 1 x 3 + x x + 1 x 6 + x 3 + x x 5 + x 4 + x + 1 x 4 + x 3 + 1 x + 1 x 2 x 3 + x + 1 x 2 + x + 1 x 2 + 1 x 5 + x 4 + x 4 + x 3 + x x 3 + x 2 + 1 x + 1 x 2 + x 3 + x 4 + x 3 + x + 1 x 2 + x + 1 x x + 1 x 2 + 1 x 2 + x x 4 + x 3 + x 3 + x x 2 + 1 x 2 + x + 1 x 3 + x 4 + x 3 + x 5 + x 4 + 1 x 2 + x + 1 x 2 + 1 x 2 + 1 x 2 + x x 3 + x 2 + 1 x 2 + 1 x + 1 x x 3 + x 2 + 1 x 4 x 5 + x 4 + 1 x 6 + x 3 + x 2 + 1 x 2 + 1 x x 1 x 4 + x + 1 x 5 + x 3 + x 6 + x 3 + x 7 + x 5 + x 2 + 1 +x 2 + 1 x 3 + x + 1 Tehát: (x 8 + x 4 + x 3 + x + 1) (x 5 + x 3 + x 2 + 1) + (x 6 + x 3 + x) (x 7 + x 5 + x 3 + x + 1) = 1.
AES (Advanced Encryption Standard) Daemen és Rijmen, belga kriptográfusok tervezték 1997-ben, 2001-ben fogadta el a NIST standardként, kulcs-mérete: 128, 192, 256 bit, blokk-mérete: 128 bit, hatékonysága: 109 Mb/sec, az AES-128 esetében: a kétdimenziós tömb, a state oszlop-száma = 4, a körkulcsok és körök száma = 10, nem használja a Feistel-sémát.
AES (Advanced Encryption Standard) Helyettesítést és permutációt alkalmaz, véges testek felett alkalmaz aritmetikai és műveletet, motiváció: kriptográfiában egész számokkal dolgozunk, 0 és 2 n 1 közötti értékekkel, és az összes n-bit hosszúságú számra szükség van. Olyan halmazt kell választani, ahol az összeadás, kivonás, szorzás, osztás után is halmazbeli elemet kapunk véges testek, pontosabban GF (2 n ) feletti véges testek.
AES az AES minden műveletet 8 biten végez, az összeadás, kivonás, szorzás, osztás a GF (2 8 ) feletti véges testben történik, összesen 30 irreducibilis polinom van, ahol az AES a következővel dolgozik: x 8 + x 4 + x 3 + x + 1 három algoritmust kell definiálni: kulcsgenerálás, titkosítás, visszafejtés.
AES-128, Kulcsgenerálás a kulcsot egy 4 4-es, kétdimenziós tömbbe rendezzük, oszloponként RK 0. minden i = 0,... 9-re: RK i 1 -t felosztjuk oszloponként : w 0, w 1, w 2, w 3, meghat. nw 0, nw 1, nw 2, nw 3 szavakat: nw 0 = temp w 0, ahol temp: rw = RotWord(w 3),, sw = SubWord(rw), rcw = Rcon(i), temp = sw rcw, nw 1 = nw 0 w 1, nw 2 = nw 1 w 2, nw 3 = nw 2 w 3, nw 0 nw 1 nw 2 nw 3 128 bites értékből álló sor, 4 4-es kétdimenziós tömbbe rendezzük, oszloponként RK i.
AES-128, Kulcsgenerálás, példa legyen a kulcs: 2b7e1516 28aed2a6 abf 71588 09cf 4f 3c, 2 dimenziós tömbbe rendezve: w 0 w 1 w 2 w 3 2b 28 ab 09 7e ae f 7 cf 15 d2 15 4f 16 a6 88 3c rw sw rcw temp cf 4f 3c09 8a84eb01 01000000 8b84eb01 Az RK 1 szavai: kétdimenziós tömbbe rendezve: nw 0 nw 1 nw 2 nw 3 a0fafe17 88542cb1 23a33939 2a6c7605 w 0 w 1 w 2 w 3 a0 88 23 2a fa 54 a3 6c fe 2c 39 76 17 b1 39 05
AES-128, RotWord, SubWord, Rcon RotWord, balra történő ciklikus eltolást hajt végre: RotWord(a 0 a 1 a 2 a 3) = (a 1 a 2 a 3 a 0) SubWord, alkalmazza byte-onként az S-boxot. Ha az átalakítandó byte például a 4a, akkor az S-box táblázat 4-ik sora és a-ik oszlopának kereszteződésénél található byte lesz az új érték: d6. Rcon az első byte-ra az x i 1 (mod x 8 + x 4 + x 3 + x + 1) hatványértéket számolja ki, a GF (2 8 ) véges testben, a további három byte értéke, azaz a 3 legbaloldalibb byte 0x00 lesz. i 1 2 3 4 5 6 7 8 9 10 Rcon(i) 0x01 0x02 0x04 0x08 0x10 0x20 0x40 0x80 0x1b 0x36
AES-128, titkosítás a bemenetet egy 4 4-es, kétdimenziós tömbbe rendezzük, oszloponként S. meghatározzuk SS =AddRoundKey(S, RK 0) minden i = 1,... 9-re: S1 = SubBytes(SS), S2 = ShiftRows(S1), S3 = MixColumns(S2), SS = AddRoundKey(S3, RK i ), az 10.körben: S1 = SubBytes(SS), S2 = ShiftRows(S1), a titkosító függvény kimenete: AddRoundKey(S2, RK 10).
AES-128, AddRoundKey, SubBytes, ShiftRows AddRoundKey a bemeneti paraméterekre byte-onként alkalmazza a műveletet. SubBytes a 4 4-es tömb byte-jaira alkalmazza az S-boxot, ShiftRows a 4 4-es tömböt byte-jaira alkalmazza a következő ciklikus eltolásokat: s 11 s 12 s 13 s 14 >> s 11 s 12 s 13 s 14 s 21 s 22 s 23 s 24 s 22 s 23 s 24 s 21 s 31 s 32 s 33 s 34 s 33 s 34 s 31 s 32 s 41 s 42 s 43 s 44 s 44 s 41 s 42 s 43
AES-128, MixColumns MixColumns a 4 4-es tömb byte-jaira alkalmazza a következő átalakításokat: ahol s 11 s 12 s 13 s 14 >> ns 11 ns 12 ns 13 ns 14 s 21 s 22 s 23 s 24 ns 21 ns 22 ns 23 ns 24 s 31 s 32 s 33 s 34 ns 31 ns 32 ns 33 ns 34 s 41 s 42 s 43 s 44 ns 41 ns 42 ns 43 ns 44 ns 1i = (0x02 s 1i ) (0x03 s 2i ) s 3i s 4i ns 2i = s 1i (0x02 s 2i ) (0x03 s 3i ) s 4i ns 3i = s 1i s 2i (0x02 s 3i ) (0x03 s 4i ) ns 4i = (0x03 s 1i ) s 2i s 3i (0x02 s 4i ). a művelet szorzást jelent (mod x 8 + x 4 + x 3 + x + 1) szerint a GF (2 8 ) véges testben.
AES-128, S-box Az S-box bemenetének bitjeit egy polinom együtthatóinak tekintjük, és meghatározzuk a polinom multiplikatív inverzét (mod x 8 + x 4 + x 3 + x + 1) szerint a GF (2 8 ) véges testben, jelöljük ezt: b = (b 7 b 6 b 5 b 4 b 3 b 2 b 1 b 0)-vel. Ezután egy affin transzformációt alkalmazunk, megkapva az S-box kimeneti bitjeit: nb = (nb 7 nb 6 nb 5 nb 4 nb 3 nb 2 nb 1 nb 0) nb 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, ahol i = 0,..., 7 és c = (c 7 c 6 c 5 c 4 c 3 c 2 c 1 c 0) = (0110 0011) = 0x63.
Példa Határozzuk meg az S-box {4a} = (0100 1010) = x 6 + x 3 + x-ra alkalmazott értékét. {4a} multiplikatív inverze: b = x 7 + x 5 + x 3 + x + 1 = (1010 1011) lesz, mert (x 6 + x 3 + x) (x 7 + x 5 + x 3 + x + 1) = 1 (mod x 8 + x 4 + x 3 + x + 1), a keresett érték nb = (1101 0110) = {d6}, mert: nb 0 = b 0 b 4 b 5 b 6 b 7 c 0 = 1 0 1 0 1 1 = 0 nb 1 = b 1 b 5 b 6 b 7 b 0 c 1 = 1 1 0 1 1 1 = 1 nb 2 = b 2 b 6 b 7 b 0 b 1 c 2 = 0 0 1 1 1 0 = 1 nb 3 = b 3 b 7 b 0 b 1 b 2 c 3 = 1 1 1 1 0 0 = 0 nb 4 = b 4 b 0 b 1 b 2 b 3 c 4 = 0 1 1 0 1 0 = 1 nb 5 = b 5 b 1 b 2 b 3 b 4 c 5 = 1 1 0 1 0 1 = 0 nb 6 = b 6 b 2 b 3 b 4 b 5 c 6 = 0 0 1 0 1 1 = 1 nb 7 = b 7 b 3 b 4 b 5 b 6 c 7 = 1 1 0 1 0 0 = 1
AES-128, S-box 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 63 7c 77 7b f 2 6b 6f c5 30 01 67 2b fe d7 ab 76 1 ca 82 c9 7d fa 59 47 f 0 ad d4 a2 af 9c a4 72 c0 2 b7 fd 93 26 36 3f f 7 cc 34 a5 e5 f 1 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 f 9 02 7f 50 3c 9f a8 7 51 a3 40 8f 92 9d 38 f 5 bc b6 da 21 10 ff f 3 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 f 4 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 f 6 0e 61 35 57 b9 86 c1 1d 9e e e1 f 8 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
AES-128, visszafejtés a blokk titkosítókra jellemzően a kör-kulcsokat fordított sorrendbe alkalmazza, az alkalmazott függvényeket fordított sorrendben veszi a titkosításnál alkalmazott sorrendhez képest, a SubBytes, ShiftRows, MixColumns, S-box függvények inverzeit használja a titkosítás nem ugyanaz, mint a visszafejtés, titkosítási sorrend: SubBytes, ShiftRows, MixColumns, AddRoundkey, visszafejtési sorrend: InvShiftRows, InvSubBytes, AddRoundkey, InvMixColumns, meg kell külön írni a titkosító és visszafejtő függvényt hátrány, de lehet ezt optimalizálni.
AES-128, S-box Az inverz S-box bemenetének bitjeit szintén egy polinom együtthatóinak tekintjük, ezen alkalmazzuk a következő affin transzformációt, ami után meghatározzuk a multiplikatív inverzet: nb i = b i+2 (mod 8) b i+5 (mod 8) b i+7 (mod 8) d i, ahol i = 0,..., 7 és d = (d 7 d 6 d 5 d 4 d 3 d 2 d 1 d 0) = (0000 0101) = 0x05.