Diszkrét matematika 11. eloadásmgyongyi/DiszkretMat/11_Szamelmelet.pdfDiszkrét matematika 11. el®adás MÁRTON Gyöngyvér [email protected] Sapientia Egyetem, Matematika-Informatika

Diszkrét matematika

11. el®adás

MÁRTON Gyöngyvé[email protected]

Sapientia Egyetem,Matematika-Informatika TanszékMarosvásárhely, Románia

2019, ®szi félév

MÁRTON Gyöngyvér 2019, Diszkrét matematika

Mir®l volt szó az elmúlt el®adáson?

az Euler függvény, az Euler-tétel

az Euler függvényhez kapcsolódó összefüggések

a Miller-Rabin prímteszt

hatványok és generátor elemek

a diszkrét logaritmus (DL) probléma

a Di�e-Hellman kulcscsere


Mir®l lesz szó?

az eukleidészi algoritmus és változatai

lineáris kongruenciák

moduláris inverz, algoritmusok

a brute-force algoritmusa kiterjesztett Eukleidész algoritmusaz Euler tétel/a kis Fermat tételen alapuló algoritmus

az RSA rendszer, baby változat


Az eukleidészi algoritmus

Az a és b egész számok legnagyobb közös osztója, az a legnagyobb számamely osztja az a-t és b-t is. Jelölése: lnko(a, b), (a, b), vagygcd(a, b)

Az a és b egész számok legnagyobb közös osztója az a d legkisebb egészszá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.

Eukleidész algoritmusa: meghatározza a legnagyobb közös osztót

Eukleidész kiterjesztett algoritmusa: meghatározza a d , x , y egészszámokat

Az a és b egész számok relatív prímek, ha lnko(a, b) = 1.

Az a1, a2, . . . , an kölcsönösen relatív prímek, ha lnko(a1, a2, . . . , an) = 1.

Az a1, a2, . . . , an páronként relatív prímek, ha lnko(ai , aj) = 1, bármelyi , j ∈ {1, 2, . . . , n}.



1. feladat

Az eukleidészi algoritmus iteratív és rekurzív változatával határozzuk meg két

szám legnagyobb közös osztóját.

Iteratív változat:

def euclid (a, b):

while True:

r = a % b

if r == 0: break

a = b

b = r

return b

Rekurzív változat:

def euclidR(a, b):

r = a % b

if r == 0: return b

return euclidR(b, r)



Megjegyzések:

hány osztást végez az algoritmus?

Lamé tétele:

1. tétel

Az eukleidészi algoritmus során végzett osztások száma nem lesz nagyobb, mint

ötször a kisebbik szám számjegyeinek száma

határozzuk meg két egymásutáni Fibonacci szám legnagyobb közösosztóját? Ekkor hány osztást végez az algoritmus?

létezik-e más algoritmus?



El®bb meghatározzuk a q osztási hányadost, majd a q segítségével az r osztásimaradékot. Minden iterációnál kiiratjuk az a, b, q, r értékeket:

def euclid(a, b):

print("%4s%4s%4s%4s" % ("a","b","q","r"))

while True:

q = a // b

r = a - b * q

if r == 0: return b

print("%4i%4i%4i%4i" % (a, b, q, r))

a, b = b, r

>>> euclid(76, 32)

a b q r

76 32 2 12

32 12 2 8

12 8 1 4

4



>>> euclid(76, 32)

a b q r

76 32 2 12

32 12 2 8

12 8 1 4

4

76 = 2 · 32+ 12 → 12 = 76− 2 · 3232 = 2 · 12+ 8 → 8 = 32− 2 · 1212 = 1 · 8+ 4 → 4 = 12− 1 · 8

4 = 12− 1 · 8 = 12− 1 · (32− 2 · 12) == −1 · 32+ 3 · 12 = −1 · 32+ 3 · (76− 2 · 32) == −7 · 32+ 3 · 76



>>> euclid(56, 15)

a b q r

56 15 3 11

15 11 1 4

11 4 2 3

4 3 1 1

1

56 = 3 · 15+ 11 → 11 = 56− 3 · 1515 = 1 · 11+ 4 → 4 = 15− 1 · 1111 = 4 · 4+ 3 → 3 = 11− 2 · 44 = 1 · 3+ 1 → 1 = 4− 1 · 3

1 = 4− 1 · 3 = 4− 1 · (11− 2 · 4) == −1 · 11+ 3 · 4 = −1 · 11+ 3 · (15− 1 · 11) == 3 · 15− 4 · 11 = 3 · 15− 4 · (56− 3 · 15) == 15 · 15− 4 · 56


Az eukleidészi algoritmus és változatai

Eukleidész kiterjesztett algoritmusa: legyenek a, b pozitív egész számok, akkorfelírható a következ® összefüggés: lnko(a, b) = xn · a+ yn · b, n ∈ {0, 1, 2, . . . },ahol xn és yn a következ® számítási sorozat n-ik tagjai:

x0 = 1, y0 = 0x1 = 0, y1 = 1xj = xj−2 − qj−1 · xj−1

yj = yj−2 − qj−1 · yj−1,

ahol qj a megfelel® hányados, amelyet az eukleidészi algoritmus soránszámolunk ki és az iterációt addig végezzük, míg 0 maradékot nem kapunk.


A kiterjesztett eukleidészi algoritmus, példa

Határozzuk meg 76 és 32 legnagyobb közös osztóját, majd azokat az x és yegész számokat, melyekre fennáll a következ® összefüggés: 76 · x + 32 · y = d ,ahol d = lnko(76, 32) .

a b q r x0 x1 y0 y11 0 0 1

76 32 2 12 0 1 1 −232 12 2 8 1 −2 −2 512 8 1 4 −2 3 5 −78 4 2 0

Tehát a megoldás: d = 4, x = 3, y = −7, és fennáll a következ® összefüggés:76 · 3+ 32 · (−7) = 4.


A kiterjesztett eukleidészi algoritmus, példa

Határozzuk meg 15 és 56 legnagyobb közös osztóját, majd azokat az x és yegész számokat, melyekre fennáll a következ® összefüggés: 15 · x + 56 · y = d ,ahol d = lnko(15, 56) .

a b q r x0 x1 y0 y11 0 0 1

15 56 0 15 0 1 1 056 15 3 11 1 −3 0 115 11 1 4 −3 4 1 −111 4 2 3 4 −11 −1 34 3 1 1 −11 15 3 −43 1 3 0

Tehát a megoldás: d = 1, x = 15, y = −4, és fennáll a következ® összefüggés:15 · 15+ 56 · (−4) = 1.


A kiterjesztett eukleidészi algoritmus

2. feladat

Eukleidész kiterjesztett algoritmusával határozzuk meg azokat a d , x , y egész

számokat amelyek teljesítik: d = x · a+ y · b.

def extEuclid (a, b):

x0, x1, y0, y1 = 1, 0, 0, 1

#print("%4s%4s%4s%4s%4s%4s%4s%4s" % ("a","b","q","r","x0","x1","y0","y1"))

#print("%4s%4s%4s%4s%4i%4i%4i%4i" % ("","","","",x0,x1,y0,y1))

while True:

q = a // b

r = a - b * q

if r == 0:

#print("%4i%4i%4i%4i" % (a,b,q,r))

return b

x = x0 - q * x1

y = y0 - q * y1

x0, x1, y0, y1 = x1, x, y1, y

#print("%4i%4i%4i%4i%4i%4i%4i%4i" % (a,b,q,r,x0,x1,y0,y1))

a, b = b, r


Lineáris kongruenciák

Az a · x ≡ b (mod m) típusú egyenletet lineáris kongruenciának hívjuk, ahol xismeretlen.

ha x0 megoldása a fenti kongruenciának és x1 ≡ x0 (mod m), akkor x1 ismegoldás

2. tétel

Legyenek a, b,m egész számok, ahol m > 0 és lnko(a,m) = d . Ha d 6 |b, akkoraz a · x ≡ b (mod m) kongruenciának nincs megoldása. Ha d

∣∣b, akkor aza · x ≡ b (mod m) kongruenciának d inkongruens megoldása van (mod m)szerint.

Az a · x ≡ b (mod m) kongruencia ekvivalens az a · x −m · y = begyenlettel.

kiterjesztett Eukleidészi algoritmussal meghatározzuk a x , y -t, úgy hogyteljesüljön: a · x +m · y = d .

A kongruencia els® megoldása x0 = x · (b/d) lesz.A kongruencia többi megoldásait az n = 1, 2, ..., d − 1 lehetséges értékekalapján, a következ®képpen számoljuk ki: xi = x0 + n · (m/d).


Példák

Határozzuk meg a 9 · x ≡ 12 (mod 15) kongruencia megoldásait.

lnko(9, 15) = 3 és 3∣∣12⇒ a kongruenciának 3 inkongruens megoldása

van (mod 15) szerint.

Kiterjesztett eukleidészi algoritmussal kapjuk: 9 · 2+ 15 · (−1) = 3, azazx = 2, y = −1.A kongruencia els® megoldása: x0 = 2 · (12/3) = 8.

A többi megoldás:

x1 = x0 + 1 · (15/3) = 8+ 5 = 13 (mod 15),x2 = x0 + 2 · (15/3) = 8+ 10 = 18 ≡ 3 (mod 15).

fennáll:

9 · 8 = 72 = 12 (mod 15),9 · 13 = 117 = 12 (mod 15),9 · 3 = 27 = 12 (mod 15),


Moduláris inverz meghatározása

1. értelmezés

Az a · x ≡ 1 (mod m) kongruenciának a megoldását, ahol lnko(a,m) = 1 az aszám moduláris inverzének hívjuk (mod m) szerint.

Megjegyzés

a fenti egyenlet egy sajátos esete az a · x ≡ b (mod m) egyenletnek:b = 1.

Példák:

Mennyi lesz 4 inverze (mod 7) szerint? Mivel kell megszorozni 4-et,hogy 1-et kapjunk?

Válasz: 2-vel, mert 4 · 2 = 1 (mod 7).

Mennyi lesz 7 inverze (mod 31) szerint? Mivel kell megszorozni 7-et,hogy 1-et kapjunk?

Válasz: 9-cel, mert 7 · 9 = 1 (mod 31).



Egy szám moduláris inverzét meghatározhatjuk:

brute-force módszerrel: az összes lehetséges értéket sorra próbáljuk

a kiterjesztett Eukleidész algoritmussal

az Euler tétel segítségével, az a · x ≡ 1 (mod m) kongruenciának a

megoldása, ahol lnko(a,m) = 1:

x = aφ(m)−1 (mod m)ha m prímszám, akkor x = am−2 (mod m)

Határozzuk meg a 13 · x ≡ 4 (mod 36) kongruencia egy megoldását, azEuler-tétel segítségével:

lnko(13, 36) = 1 ⇒ a kongruenciának egy megoldása van (mod 36)szerint.

meghatározzuk:φ(36) = φ(22 · 32) = φ(22) · φ(32) = (22 − 21) · (32 − 31) = 2 · 6 = 12

13 inverze (mod 36) szerint: 13φ(36)−1 = 1311 = 25 (mod 36)

a kongruencia megoldása: 25 · 4 = 28 (mod 36).



3. feladat

A kiterjesztett Eukleidész algoritmussal határozzuk meg a inverzét (mod m)szerint.

def inverz_(a, m):

d, x, y = extEuclid(a, m)

if d != 1:

print ('nincs inverz')

return -1

return x % m

Megjegyzések:

A kiterjesztett Eukleidész algoritmus az x és y értékekben negatív számot ismeghatározhat.

azt szeretnénk hogy a moduláris inverz, ha létezik, akkor az mindig pozitív értéklegyen

a Python % operátora a legkisebb pozitív maradékot határozza meg:

>>> -5 % 7

2



A kiterjesztett Eukleidész algoritmusban, ha csak inverz számításra használjuk, akkortöbb m¶veletet is elhagyhatunk:

def inverz(a, m):

x0, x1 = 1, 0

b = m

while True:

q = a // b

r = a - b * q

if r == 0:

if b != 1: return -1

else: return x1 % m

x = x0 - q * x1

x0, x1 = x1, x

a, b = b, r

>>> inverz(13, 36)

25

ellen®rzés:

>>> (13 * 25) % 36

1


Az RSA rendszer

RSA (Rivest, Shamir, Adleman), 1976-ban publikálták,

az RSA-OAEP (Bellare, Rogaway) verziót 1995-ben publikálták, amelyetstandardizáltak és a mai gyakorlatban ezt használják,

alkalmas titkosításra és kulcscserére is,

a gyakorlatban kulcscsere protokollokban használják, mert nagyadathalmaz titkosítása esetén nem hatékony,

a rendszer helyessége az Euler-tétellel bizonyítható,

a rendszer biztonsága a faktorizációs probléma nehézségén alapszik: nincshatékony algoritmus, amely meghatározná egy "nagy" összetett számprímosztóit, a jelenlegi standardok min. 512 bites prímszámokkaldolgoznak,

a továbbiakban az 1976-ban publikált változatot mutatjuk be.


Az RSA rendszer

Az aszimmetrikus titkosító rendszerek családjába tartozik, kulcscsere

esetében:

egy eszközön, általában a kliens gépen kigenerálnak egymesterkulcsot,a szervert®l kapott nyilvános kulccsal, a kliens eszköz titkosítja amesterkulcsot, majd a titkosított értéket egy nyilvános csatornánátküldi a szervergépre,a szerver oldalon egy titkos kulccsal visszafejtik a kapott adatot, ígya szerver oldalon is meg lesz a mesterkulcs,a további titkos üzenet-cserék, más algoritmusokkal, a mesterkulcssegítségével történnek.


Az RSA titkosító rendszer- baby változat

A mesterkulcsot a továbbiakban nyílt-szövegnek fogjuk hívni.

A rendszerben három algoritmust kell megadni: kulcsgeneráló algoritmus,titkosító algoritmus, visszafejt® algoritmus

a kulcsgeneráló algoritmus: bemeneti paramétere a generált kulcs

bit-hossza (ez min. 1024 bit kell legyen), kimenetként megadja a

nyilvános és titkos-kulcsot

legyen p, q két prímszám, n = p · q,legyen 1 < e < n, úgy hogy lnko(e, φ(n)) = 1 és legyen d az einverze (mod φ(n)) szerint.nyilvános kulcs: (e, n), titkos kulcs: (d , n)

a titkosító algoritmus: bemeneti paramétere a nyilvános kulcs és a Knyílt-szöveg; meghatározza ck = K e (mod n) titkosított szöveget

a visszafejt® algoritmus: bemeneti paramétere a titkos kulcs és atitkosított szöveg, meghatározza a K = cK d (mod n) nyílt-szöveget.


Az RSA, számpélda- baby változat

Kulcsgenerálás

Legyen p = 61, q = 97 két prímszám.Meghatározzuk:

n = 61 · 97 = 5917,φ = (p − 1) · (q − 1) = 60 · 96 = 5760.

Legyen e = 7, ahol lnko(7, φ) = 1.Meghatározzuk e inverzét (mod φ) szerint, kapjuk: d = 823, mert7 · 823 = 1 (mod 5760).A nyilvános-kulcs : (7, 5917).A titkos-kulcs : (823, 5917).

Titkosítás vagy kulcsmegosztás (bárki titkosíthat)

A K = 2014 mesterkulcs értéket szeretnék titkosítani/megosztani.Ekkor a titkosított érték: cK = 20147 ≡ 1526 (mod 5917).

Visszafejtés (csak a titkos-kulcs birtokosa tudja visszafejteni)

K = 1526823≡ 2014 (mod 5917).


RSA kulcsgeneráló algoritmus- baby változat

4. feladat

Az alábbi Python függvény bemenete egy k egész szám, a rendszer biztonsági

paramétere. Kimenete az (e, d , n, p, q), ahol a nyilvános kulcs: (e, n), a titkos

kulcs: (d , n).

from math import gcd

def RSA_key_gen (k):

p = prim_gen ( k//2 )

q = prim_gen ( k//2 )

n = p * q

phi = (p-1) * (q-1)

e = 3

while True:

if gcd(e, phi) == 1: break

e += 2

d = inverz(e, phi)

return (e, d, n, p, q)



a könyvtárfüggvény gcd meghatározza e és phi legnagyobb közösosztóját,

nincsenek megírva a következ® függvények:

a prim_gen egy k/2 bit-méret¶ prímszámot generál a Miller-Rabinalgoritmus segítségével,az inverz meghatározza e inverzét (mod (p − 1) · (q − 1)) szerint,a kiterjesztett eukleidészi algoritmussal, ez lesz d .


Az RSA titkosító algoritmus- baby változat

5. feladat

Az alábbi Python függvény bemenete a K egész szám a [0, . . . , n − 1]intervallumból, amit titkosítani akarunk és az (e, n) nyilvános-kulcs. Kimenete

a cK titkosított érték.

def RSA_crypt (K, e, n):

cK = pow(K, e, n)

return cK

A pow(K, e, n) meghatározza az K e (mod n) értékét.

Példa: legyenek (e, n) = (7, 5917), a kulcsgenerálásnál meghatározottértékek,

az K = 2014 titkosított értéke: cK = 20147 ≡ 1526 (mod 5917).


Az RSA visszafejt® algoritmus- baby változat

6. feladat

Az alábbi Python függvény bemenete a cK egész szám és a (d , n) titkos-kulcs.

Kimenete az K visszafejtett érték.

def RSA_decrypt (cK, d, n):

K = pow(cK, d, n)

return K

Példa: legyenek (d , n) = (823, 5917), a kulcsgenerálásnál meghatározottértékek,

ha cK = 1526 értéket kell vissza fejtenünk, akkor fennáll:

K = 1526823 ≡ 2014 (mod 5917).


Az RSA rendszer- baby változat

7. feladat

Az alábbi Python függvény egy beolvasott egész szám titkosítását, majd

visszafejtését végzi a korábbi slide-okon megadott függvények segítségével

def RSA_fel():

k = int(input('bit meret: '))

e, d, n, p, q = RSA_key_gen(k)

print ('nyilvanos kulcs: ', e, n)

print ('titkos kulcs: ', d, n)

print('kerek egy szamot, legyen kisebb mint: ', n)

K = int(input())

cK = RSA_crypt(K, e, n)

print ('titkositott ertek: ', cK)

K = RSA_decrypt(cK, d, n)

print ('visszafejtett ertek:', K)



ha n = p · q, akkor az Euler függvény: φ(n) = (p − 1) · (q − 1),

a generált p, q prímszámokat és a φ(n) értékét titokban kell tartani; atitkosító és visszafejt® algoritmusok nem használják ®ket

az e értéket választhatjuk véletlenszer¶en, de hatékonyság szempontjábóla standard a 65537 konstans értékkel dolgozik,

a standard el®írja, hogy a p és a q 512 bites prímszámok legyenek, ekkoraz n 1024 bites lesz, ami azt jelenti, hogy nem lehet meghatározni nszorzótényez®it,

ha d is megközelít®leg 1024 bites, akkor p és a q ismerete nélkül, egyel®renincs algoritmus, amely meghatározná a d-t,

a d értéke a p és a q ismeretében, a kiterjesztett eukleidészi algoritmussalazonban meghatározható,

Wiener-algoritmusa: meghatározza a d értékét, ha ez kicsi, anélkül, hogyismerné a p, q értékeket.



Miért alkalmazható a gyakorlatban a rendszer?

1024 bites kulcsok esetében is:

hatékony algoritmussal meg lehet határozni a nyilvános és titkos-kulcsot:Miller-Rabin valószín¶ségi prímteszt, kiterjesztett eukleidészi algoritmus,

a nyilvános-kulcs ismeretében hatékony algoritmussal meg lehet határoznia titkosított szöveget: moduláris hatványozó algoritmus,

a titkos-kulcs ismeretében hatékony algoritmussal meg lehet határozni anyílt-szöveget: moduláris hatványozó algoritmus,

a titkos-kulcs hiányában nem lehet meghatározni nyílt-szöveget



Megjegyzések:

A titkosító algoritmus nagy számok titkosítására képes.

A nyílt szöveget át kell alakítani számmá: a nyílt szöveg bet¶it (bájtjait)256-os számrendszerbeli számokként kezeljük, amelyeket átalakítunk256k -os számrendszerbe, ahol a k értékét a kulcsok bit-mérete határozzameg.

A nyilvános és titkos kulcsok állományokban vannak eltárolva, általábanbase64 formában.

a 9. laborban megoldott kliens-szerver alkalmazást találunk, amely egymesterkulcs értékét osztja meg RSA-val, hasonlóan, mint a DH kulcscsere.

Az RSA rendszer egy angol nyelv¶ bemutatója, videó!


https://www.khanacademy.org/computing/computer-science/cryptography/modern-crypt/v/rsa-encryption-step-2

Documents

Diszkrét matematika 11. eloadásmgyongyi/DiszkretMat/11_Szamelmelet.pdfDiszkrét matematika 11. el®adás MÁRTON Gyöngyvér [email protected] Sapientia Egyetem, Matematika-Informatika