De complexiteit van het Discrete Logaritme Probleem

Transcriptie

1 De complexiteit van het Discrete Logaritme Probleem Ivor vand der Hoog ( ) Inleiding Mathematics is the queen of sciences, and number theory is the queen of mathematics. Toen Gauss deze uitspraak deed over getaltheorie was getaltheorie een abstracte bezigheid die geen enkele toepassing in het dagelijks leven had. Nu leven we in een tijdperk waar technologie en ons leven op ontelbaar veel manieren met elkaar verwikkeld zijn en waarin een angst voor big brother een vraag voor goede cryptografie tot leven roept. Deze paper bespreekt het Discrete Logaritme Probleem uit de getaltheorie en in het bijzonder algoritmen om het probleem op te lossen en diens complexiteit. Deze paper zal beginnen met het geven van een aantal definities. Daarna worden vier groepsalgoritmen besproken. Vervolgens worden een paar eigenschappen van groepen die de algoritmen gebruiken bewezen en tot slot wordt er nog verteld over groepsalgoritmen in de praktijk. 2 Definities en het Discrete Logaritme Probleem Het Discrete Logaritme Probleem (DLP) is een probleem uit de getaltheorie die vele toepassingen heeft op het gebied van cryptografie. Het probleem is samen te vatten als: Definitie: 1. Gegeven een groep G, een groepselement g G en een a. Vindt een x Z zodanig dat g x = a. 2.1 Complexiteit Wanneer we het hebben over complexiteit dan zullen we het hebben over zowel complexiteit in tijd als in ruimte. Complexiteit in tijd zullen we zien als de bovengrens van het aantal operaties per inputgrootte. Complexiteit in de ruimte zullen we zien als de bovengrens voor het aantal geheugenplaatsen per inputgrootte. Een operatie noemen we het vermenigvuldigen van een groepselement en een geheugenplaats zien we als het benodigde geheugen voor het opslaan van een groepselement plus bijbehorende hash en (soms nodige) indices. De lengte van de input zullen we n noemen en n zal gelijk zijn aan het aantal elementen in G. Dat wordt ook wel geschreven als ORD(G) of G. 2.2 Aannames Meer kennis over een probleem kan leiden tot lagere complexiteit. Wanneer we bijvoorbeeld weten dat we het hebben over de additieve groep Z + /nz en diens generator 1 volgt direct dat x gelijk is aan a. In het bijzonder is de complexiteit van dit probleem O(1). Wanneer g geen generator van G is maar bijvoorbeeld een kwadraat van een generator volgt er dat we maximaal n 2 elementen hoeven langs te gaan, zo kan kennis over g ook de complexiteit naar beneden brengen. Gebrek aan kennis kan leiden tot hogere complexiteit. Wanneer we bijvoorbeeld niet weten of een gegeven a een element van de groep is of niet weten wanneer elementen gelijk aan elkaar zijn kunnen we per ongeluk dubbel werk verrichten wat de complexiteit verhoogd. (elementen kunnen bijvoorbeeld in dezelfde equivalentieklasse zitten zonder dat we het weten waardoor we als het ware hetzelfde element twee keer testen). Daarom nemen we de volgende aannames bij het bespreken van de complexiteit van algoritmen: 1

2 1. We beschouwen algoritmen als algemene groepsalgoritmen (algoritmen die enkel gebruik maken van de groepsstructuur) tenzij anders vermeld wordt. 2. We weten wanneer elementen gelijk aan elkaar zijn. 3. g is een generator van de groep, in het bijzonder weten we alle elementen van G en is G cyclisch. 4. a is een element van G. 3 Algroritmen voor het Discrete Logaritme Probleem De makkelijkste aanpak om het discrete logaritme te vinden is om alle machten van g uit te rekenen tot we a hebben bereikt. Het uitvoeren van dit algoritme en het opslaan van alle uitkomsten kost O(n) tijd en ruimte. Wanneer we gebruik maken van kennis over de groepsstructuur vinden we algoritmen met een kleinere loop- en opslagtijd. 3.1 Baby-step, Giant-step Baby-step Giant-step is een algoritme van Daniel Shanks dat werkt volgens een meet in de middle idee. Laat m gelijk zijn aan n. We schrijven x = im j met 0 i, j m. Het is eenvoudig te zien dat x hiermee de waarden 0 tot en met n kan bereiken door op te merken dat voor vaste i geldt dat x [im m, im] en dat [0, n] m 1 [im m, im]. We maken nu twee gesorteerde sets van tupels. i=1 A = {(i, g im ), i [1, m]} B = {(j, ag j ) j [0, m]} Wanneer een element uit A gelijk is uit die van B volgt: a g j = g am a = g am j. Wanneer we beide sets construeren en opslaan en een zoekmethode zoals een hashtabel gebruiken om in O(1) tijd op te zoeken of een element in set A ook in set B zit hebben we een looptijd en een opslagruimte van O( n). Het algoritme is deterministisch, dat houdt in dat wanneer alle elementen uit A en B worden vergeleken en er een x is zodanig dat g x = a dat die x dan ook wordt gevonden. Het algoritme werkt ook wanneer de orde van de groep, n, niet bekend is. In dit geval kiest men een grote n en m = n, als [0, n] [0, n ] dan zeker [0, n] m 1 [im m, im ]. Wanneer n niet groot genoeg is vind je in O( n ) tijd geen x en kun je n verdubbelen en het nogmaals proberen. i=1 3.2 Two grumpy giants and a baby. Er is een verbetering aangebracht op het baby-step, giant-step algoritme door Bernstein. Omdat dit een vrij complex algoritme is zal in grove lijnen het idee van het algoritme worden uitgelegd. Voor een secure uitleg verwijs ik naar de uitleg van dr. Bernstein zelf, de link staat in de appendix. Het idee is om niet een giant te hebben die grote stappen neemt maar om er twee te nemen die in tegengestelde richting en op een ander startpunt lopen. In het bijzonder nemen we als eerste giant voor een m (komen we later op terug) de set A = {(i, a 1 g 2im ) i [0, m]} en de tweede giant doorloopt set B = {(j, a 2 g 2im+1 ) j [0, m]}. Dit zorgt ervoor dat de eerste giant alle even exponenten van g dekt en de tweede giant alle oneven, in het bijzonder kan het nooit zijn dat x A, y B zdd x = y. Zou dat wel zo zijn dan delen A en B dezelfde orbit en volgt A = B wat het hele idee is dat we twee sets hebben. Het is ook duidelijk te zien dat A B alle mogelijke machten voor a g m in de groep geeft. De derde set is de baby en die noemen we C = {(k, a 0 g k ) k [0, m]}. Het idee is dat we alle drie de sets gelijktijdig ontwikkelen en checken of er ergens een giant gelijk is aan een baby. Wanneer er twee elementen uit een set gelijk aan elkaar zijn volgt er: a {0,1,3} g y = a {0,1,3} g z waaruit we het gewenste antwoord kunnen halen. Het idee achter dit algoritme is dat Baby-step, Giant-step altijd wel een antwoord vindt maar dat traag doet en relatief veel geheugen inneemt. Als we schrijven a x g y en we beschouwen het tupel (x, y). In het oorspronkelijke geval doorloopt de baby de ruimte: A = (x, y) = (1, 0) + {[0, n] (0, 1)} en de giant de 2

3 ruimte B = (x, y) = (0, 1) + {[0, n] (0, n)}. Het idee is nu dat we het aantal slopes in die ruimten bekijken. Slopes komen voort uit een analyse van de elliptische curve van de groep, dit kan alleen als de groep een Finite Field is en meer uitleg over dit soort groepen is te vinden in het paper van Mark Kamsma. Stel je het een punt Q in G en je wilt weten voor welke x geldt g x = Q. Dan blijkt het zo te zijn dat elke gevonden slope staat voor een oplossing voor een Q G. Het blijkt ook zo te zijn dat het aantal slopes gelijk is aan λ m = A B = ORD(A B). De kans dat je een oplossing hebt gevonden voor de specifieke a wordt dan λ m /n. Stel nu dat je m kleiner kiest dan n dan weet je bij beide algoritmen niet zeker of de oplossing van het DLP er in zit. Maar bij two grumpy giants doorlopen we drie ruimten. De twee giant ruimten: A = (x, y) = (1, 0) + {[0, m] (0, 2m)}, B = (x, y) = (2, 0) {[0, m] (0, 2m + 1)} en de baby C = (x, y) = (0, 0)+{[0, m](1, 0)}. Het is aan te tonen dat giants per m meer slopes genereren dan baby s en dus dat two grumpy giants meer slopes heeft per m. Hierdoor is de kans groter dat de oplossing voor het DLP er wel in zit en de kans dus groter dat je na minder stappen klaar bent. 3.3 Pollard rho Deel 1 van Pollard rho Het Pollard Rho algoritme heeft dezelfde looptijd als het algoritme van Shanks maar gebruikt minder opslagruimte. Bij het eerste deel van het Pollard Rho algoritme zoeken we een α en β zodat a α = g β. Hiervoor gebruiken we een random functie f : G > 1, 2, 3. We maken vervolgens een reeks x i met als startwaarde x 0 het eenheidselement e van G op de volgende wijze: ax i if f(x i+1 ) = 1 x i+1 = x 2 i if f(x i+1 ) = 2 (1) gx i if f(x i+1 ) = 3 Hieruit volgt dat x i = a ai g bi. We kunnen ook een reeks opstellen om a i en b i te berekenen. Stel f(x i+1 ) = 1 dan weten we dat er minstens 1 a is en verder plus even veel a s als er voor x i zijn. Op dezelfde wijze weten we foor f(x i+1 ) = 3 dat er minstens 1 g staat en verder plus even veel g s als voor x i. Tot slot weten we dat voor f(x i+1 ) = 2 dat er twee maal zo veel a s en g s zijn als voor x i. Er volgt: a i + 1 if f(x i+1 ) = 1 a i+1 = 2 a i if f(x i+1 ) = 2 (2) a i if f(x i+1 ) = 3 b i if f(x i+1 ) = 1 b i+1 = 2 b i if f(x i+1 ) = 2 b i if f(x i+1 ) = 3 Met a 0 = b 0 = 0. We zoeken nu een i en een j zodat x i = x j met i j, dat noemen we een botsing. Hieruit volgt dat α = a i a j mod n en β = b i b j mod n. Verwachte looptijd van het eerste deel van Pollard Rho We merken op dat als er een botsing periodiek is op de volgende manier. Stel x i = x j dan volgt daaruit dat: a ai g bi = a aj g bj g aix g bi = g ajx g bi g (ai aj)x+(bi bj) = 1 (4) Zo kunnen we zien dat de gelijkheid periodiek is met periode p = i j. In het bijzonder kunnen we de botsing schrijven als x i = x i+kp. Bij Pollard Rho ontwikkelen we twee reeksen. x i en x 2i. Het feit dat de gelijkheid een periode heeft zorgt er voor dat we per ontwikkeling van de rij enkel x i = x 2i hoeven te checken want dan komen we ooit op i = p en dan geldt de gelijkheid. De verwachte looptijd van is ongeveer 3 n stappen. Deze verwachtingswaarde halen we uit een afschatting van het birthday probleem: (3) Stel we hebben n nummers. dat ze allemaal uniek zijn: Als we k willekeurige nummers uit die verzameling kiezen is de kans P (n, k) = ( n k ) k! k n k = (1 t n ) (5) 3

4 Merk nu op dat geldt 1 t n 1) en dan voor x = t n : e x = lim (1 + x m m )m (1 + x 1 )1 k p(n, k) = (1 t k n ) e t k t n = e n De somreeks in de e-macht kunnen we vervolgens op de volgende manier omschrijven: k t n = 1 n k k(k 1) = k2 2n 2n (6) Stel nu p(n, k) = 1/2 dan volgt met het trekken van de log dat: k 2 2n = ln(2) k 2n ln(2) 1.2 n (7) Dus na ongeveer 1.2 n hebben we kans 0.5 om x i = x 2i te hebben. Er volgt dat na ongeveer 3 n we verwachten dat we x i = x 2i. De grote winst van dit algoritme vindt men in de opslagruimte die er nodig is. Je controleert steeds enkel of x i = x 2 i en hebt de voorafgaande waarden dus niet allemaal op te slaan, dit is een grote verbetering ten opzichte van het geheugengebruik van Small-step, big-step. Het tweede deel van Pollard Rho Stel we hebben nu x i = x 2i dan volgen α en β daaruit. Er volgt: a α = g β g xα = g β x = βα 1 mod n Merk op dat dit niet werkt als α geen inverse heeft modulo n. Wanneer α geen inverse heeft modulo n kan nog steeds x worden gevonden. We noemen de ggd(α, n) = d. Er volgt met extended Euclides dat d = u α + v n. We verheffen beide kanten tot de macht u. Er volgt: a uα = a uα 1 = a uα+vn = a d = g dx = g uβ x = uβd 1 mod n Wanneer d ook geen inverse heeft kun je dit weer toepassen op a d = g uβ tot je een d krijgt waarvoor dat wel geldt of Pollard Rho nogmaals uitvoeren. Het verbeteren van Pollard Rho In de praktijk is de looptijd van het Pollard Rho algoritme goed naar beneden te brengen. Pollard Rho gedraagt zich als een random walk door de ruimte van mogelijke logaritmen. In het bijzonder ben je enkel geïnteresseerd in het vinden van een i zodat x i = x 2i en maken alle waarden van i die daar aan voorafgaan niets uit. Het veranderen van de random functie f : G > {1, 2, 3} zorgt er voor dat je een compleet andere wandeling door de ruimte van mogelijke logaritmen maakt. Deze twee eigenschappen maken het makkelijk om dit proces te paralelliseren. Wanneer we de inverse van a weten kunnen we schrijven: g x = a g x = a 1. Kennis over x geeft dan kennis over x en andersom. Wanneer we x R x als een equivalentierelatie beschouwen kunnen we de ruimte opdelen in equivalentieklassen en zo de zoekruimte halveren. 3.4 Pohlig-Hellman Het Pohlig Hellman algoritme werkt voor cyclische multiplicatieve groepen met gladde orde. We noemen een integer glad wanneer deze geen grote priemfactoren bevat. Het idee van het algoritme is dat je het probleem opsplitst in kleinere problemen per priemfactor en die oplost. Daarna gebruiken we de Chinese resttelling om de oplossing per priemfactor terug te leiden tot een oplossing voor het DLP. 4

5 De basis van het algoritme Stel dat we rekenen in Z /pz en p gelijk is aan k i=1 pci i. We bekijken het algoritme per p ci i en het is voor elke priemfactor analoog. x heeft de mogelijke waarden [1, n] en we bewijzen later dat n het product is van Z /p ci i Z, voor het gemak noemen we die orde per pci i even p 0 i. Deze samenstelling zorgt dat we voor vaste i kunnen schrijven: x = x i +p 0 i t voor een t Z. Nu verheffen we beide kanten tot de macht q = n, er volgt: p 0 i g qx = a q g qxi g qp0 i t = a q (g q ) xi 1 t = a q g xi = a Omdat x i < n is dit probleem makkelijker op te lossen. Wanneer elke x i is berekend kan hiermee met de Chinese reststelling x worden berekend. De looptijd van het algoritme is gelijk aan de som van de looptijden voor elke priemfactor plus de tijd. 4 De correctheid van de algoritmen 4.1 De Chinese reststelling Bij Pohlig-Hellman maken we gebruik van de Chinese reststelling om de resultaten voor de priemfactoren om te schrijven tot een antwoord van het DLP. Het is belangrijk om te weten waarom zoiets geldig is. De Chinese reststelling stelt dat als getallen p i onderling priem zijn en de modulus van de cyclische multiplicatieve groep n = i p i en voor alle i geldt x i = x (mod n) dat dan volgt x = i M i x i met M i mod p j = 0 voor i j en M i mod p i = 1. Dit resultaat verkrijgen we door op te merken dat Z /nz = Z /p 1 Z Z /p 2 Z... Z/p k Z. In het bijzonder vormen de M i s dan een basis van Z/nZ en daarom mogen we elke element van Z/nZ uitdrukken in factoren op die basis. We bewijzen dit isomorfisme per inductie: We beginnen door aan te tonen dat Z/nZ = Z/p 1 Z Z/qZ met q = n/p 1. Merk op dat p 1 en q onderling priem zijn omdat ze beide uit niet gedeelde priemfactoren van n bestaan. We nemen de afbeelding φ(x) = (x mod p 1, x mod q). Allereerst tonen we aan dat de afbeelding injectief is. Stel dat er x en een y zijn zodanig dat phi(x) = phi(y) = (a, b). Merk op dat we kunnen schrijven x = am 1 + bm q maar ook y = am 1 + bm q omdat p en q onderling priem zijn (dit volgt weer uit dat q bestaat uit priemfactoren van n ongelijk aan p). Er volgt x = y. De afbeelding is ook surjectief omdat we voor alle (a, b) direct een x kunnen vinden via x = am 1 + bm q. Tot slot hoeven we enkel aan te tonen dat φ(x y) = φ(x)φ(y). We schrijven x = a x M 1 + b x M q en y = a y M 1 + b y M q. Er volgt: x y = (a x M 1 +b x M q )(a y M 1 +b y M q ) = a x a y M 1 M 1 +a x b y M 1 M q +a y b x M 1 M q +b x b y M q M q (8) Merk op dat geldt: M 1 mod p 1 = 1 (9) M q mod p 1 = 0 (10) M 1 mod q = 0 (11) M q mod q = 1 (12) Er volgt dat φ(x y) = (a x a y, b x b y ) = φ(x)φ(y). Er is dus bewezen dat Z/nZ = Z/p 1 Z Z/qZ Het bewijs wordt afgemaakt door dit proces te herhalen en aan te tonen dat Z/qZ = Z/p i Z Z/q Z voor q = q p i. 5

6 4.2 Het factoriseren van een priemgetal Algoritmen zoals Poligh-Hellman gebruiken de priemfactoren van de orde van de groep om de looptijd van het algoritme te verkleinen. Versleutelalgoritmen zoals RSA werken op een multiplicatieve groep modulo een product van priemfactoren om zo hun decrypten sneller te maken. Het is daarom belangrijk om te weten hoe de priemfactoren van een getal gevonden kunnen worden of hoe men priemgetallen vindt om een getal uit priemfactoren samen te stellen. Stel dat we n willen factoriseren. Dan zoeken we eerst twee getallen a en b zodanig dat a 2 b 2 = 0 mod n, hoe men die vindt wordt nu niet op in gegaan. Stel nu dat n op te delen is in twee ongelijke priemfactoren p en q. Dan volgt dat pq (a 2 b 2 ) pq (a 2 + ab ab b 2 ) pq (a + b)(a b). Hieruit volgt dat p = (a + b) en q = (a b) of andersom. Het vinden van a en b blijkt enkel even lastig te zijn als het oplossen van het DLP probleem. 4.3 Lagrange De stelling van Lagrange zegt dat de orde van een subgroep van een eindige groep, een deler is van de orde van de groep. Stel we hebben een groep G en een subgroep H. We nemen een element g 1 G maar buiten H en noteren g 1 H = {g 1 h h H}. We stellen dat g 1 H dezelfde grootte heeft als H en dat H en g 1 H onsamenhangend zijn. Het eerste in eenvoudig aan te tonen, de afbeelding gh heeft immers een inverse (vermenigvuldigen met g 1 en dus is het een bijectie, hieruit volgt dat de sets even groot zijn. Het tweede leiden we af uit een tegenspraak: Stel dat x = g 1 h 1 en x H, dan volgt er dat g1 1 = h 1 x 1 en dus g 1 H. Maar we hadden g 1 buiten H gekozen dus er volgt een tegenspraak. We noemen de set g 1 H ook een subset van G en gaan en zoeken met inductie een g k die aan deze eigenschappen voldoet tot we precies G hebben gevuld. De orde van G bestaat dus uit een paar keer de orde van H, dus de orde van G deelt H. Hieruit volgt ook direct dat de orde van elk element een deler is van de orde van G omdat elk element zijn eigen subgroep kan vormen. Daaruit leidden we de bekende en veel gebruikte g G = 1 af. 5 Groepsalgoritmen op het domein genaamd de praktijk 5.1 Een voorbeeld In de praktijk vinden we veel encryptie-algoritmen die op groepen (en zelfs ringen) zijn gebaseerd en die gebruikmaken van de groepssctructuur. Een hele bekende is RSA die rekent in Z /pqz met p en q grote priemgetallen, merk op dat zo n keuze zorgt ervoor dat Pohlig-hellman niet te gebruiken i omdat pq niet glad is. Groepsalgoritmen worden voornamelijk voor asymmetrische encryptie gebruikt, de moeilijkheid van het DLP zorgt ervoor dat deze algoritmen veilig zijn. We zullen dit demonstreren aan de hand van een voorbeeld. We merken eerst op dat als we willen dat een bericht a te schrijven is als g x voor een generator g en een x dat dan a wel een element van de groep moet zijn. Alice en Bob willen een bericht uitwisselen over Bob zijn date laatst en het blijkt dat woorden over het uitgaansleven van Bob niet altijd een groepselement hoeven te zijn. We merken twee manieren op om dit op te lossen: Of we stellen woorden gelijk aan bitstrings en dus getallen. Als we nu rekenen in g = Z/pZ dan is elk getal dat ongelijk is aan nul een groepselement (we verwijzen naar het dictaat). Voor dit geval verwijzen naar het algoritme van Elgamal die ze in staat stelt een veilig bericht te sturen. De tweede optie is dat Alice en Bob symmetrische encryptie gebruiken en enkel asymmetrische encryptie om de sleutel uit te wisselen. In dit geval kiest Alise een geheel getal a en BoB een geheel getal b. Samen kiezen ze publiekelijk een groep G en een generator g. Alice stuurt Bob g a en Bob Alice g b. Er volgt dat ze lokaal g ab kunnen berekenen en dus een sleutel hebben uitgewisseld. 5.2 De moeilijkheid van het probleem We hebben aangetoond een paar algoritmen laten zien die in O( n) tijd en ruimte het DLP probleem weten op te lossen. Men zou kunnen spreken van een polynominale complexiteit tot n. De meest gebruikte groep is Z /p 0 Z voor een getal p. We tonen aan dat als de modulus p 0 in dit geval een product is van unieke priemgetallen dat de orde n = i=1 n(p i 1). Stel we hebben Z /pz dan volgt uit een eerder 6

7 aangetoond isomorfisme dat we dat ook kunnen schrijven als Z /p 1 Z... Z /p n Z. In het bijzonder is de orde gelijk aan het product van de orde van elk deel van het cartesisch product. Het dictaat stelt dat φ(p i ) = (p i 1). Kiezen we de modulus p 0 dus als een combinatie van priemfactoren dan weten we dat het aantal groepselementen ongeveer lineair schaalt met p 0 en de rekentijd dus ongeveer O(p 0 ) is. Maar lineair in de waarde van p 0 impliceert exponentieel in de lengte van de bitstring die p 0 moet voorstellen en dus noemen we het probleem NP. 6 Conclusie De werking en de complexiteit van een aantal algoritmen voor het oplossen van het discrete logaritme probleem werden besproken. We hebben fundamentele stellingen voor de werking en de veiligheid van de algoritmen bewezen en anders verwezen naar andere bronnen. De genoemde algoritmen hadden allemaal een looptijd van \ waarbij n de orde is van de groep die ze behandelen en dat het probleem dus NP is in het aantal bits van n, behalve het algoritme van P ohlig Hellman welke kennis over het probleem gebruikt om de snelheid te verhogen. Ook werd verteld hoe men die kennis zou kunnen verkrijgen wanneer men die niet heeft en er werd genoemd dat dat probleem net zo moeilijk is als het DLP zelf. Voor verdere informatie over de genoemde algoritmen verwijzen we naar de appendix, wanneer de lezer wilt lezen over meer soorten goepsalgoritmen raadden we de index calculus aan. References [1] Armstrong M, Groups and Symmetry, Springer [2] Bernstein D, Lange T Two grumpy giants and a baby, Proceedings of the tenth Algorithmic Number Theory Symposium 2012 [3] Galbraith S, Wang P, Zhang F, Computing Elliptic Curve Discrete Logarithms with Improved Babystep Giant-step Algorithm, University of Auckland, Shenzhen University, Sun Yat-sen University, 2014 [4] McCurley K, The Discrete Logarithm problem, Symposia in Applied Mathematics, volume [5] Tel G, Cryptografie, de beveiliging van de digitale maatschappij., Universiteit Utrecht 2006 [6] Zametki, Complexity of a determinate algoritm for the discrete logarithm, Mathematical notes, Vol 55, no 2,