Processing math: 100%
Innehåll[-] Feedback

Talteori och RSA-kryptering

Modulär- eller kongruensaritmetik: Grundbegrepp och beteckningar [-]

Z/nZ: Kongruens- eller restklasser [-]

Relationen n är en ekvivalensrelation i mängden Z och delar Z i ekvivalensklasser som kallas kongruens- eller restklasser och dessa är mängderna
{,n+1,n,n1,0,2n1,n,},
{,n+1,n+1,n1,1,2n1,n+1,},

{,n+1,1,n1,n1,2n1,2n1,},
i vilka alla element är kongruenta med varandra modulo n.
Följande beteckningar används när n>0: [k]n={mZ:mnk}={mZ:mod(m,n)=mod(k,n)},Z/nZ={[k]n:k=0,1,2,,n1}.

Obs! [+]

Eftersom mod(m1,n)=mod(m2,n)[m1]n=[m2]n så väljs ofta elementet mod(m,n) till representant för restklassen [m]n så att man tex. kan prata om talen 0,1,2,,5 som element i mängden Z/6Z i stället för mängderna [0]6,[1]6,,[5]6. Ibland skriver man ¯kni stället för [k]n och Zn i stället för Z/nZ.

Addition, subtraktion och multiplikation i Z/nZ [-]

Man kan visa att ifall a1na2ochb1nb2 så gäller (a1+b1)n(a2+b2)(a1b1)n(a2b2)(a1b1)n(a2b2) Därför kan man definiera räkneoperationer mängden Z/nZ på följande sätt: [a]n+[b]n=[a+b]n,[a]n[b]n=[ab]n,[a]n[b]n=[ab]n,[a]jn=[aj]n,jN0, och alla "normala" räkneregler (bortsett från de som behandlar olikheter) är fortfarande i kraft.

Exempel [+]
Stämmer det att 3|5742385242417 dvs. delar 3 talet 5742385242417?
Svaret är jakande eftersom summan av siffrorna i talet 5+7+4+2+3+8+5+2+4+2+4+1+7 är delbart med 3.
En varför gäller den här regeln? [+]
  • I decimaltalssystemet avses med talet xnxn1x1x0 talet m=xn10n+xn110n1++x110+x0100.
  • [10j]3=[10]j3=[1]j3=[1j]3=[1]3.
  • Av detta följer påståendet eftersom [m]3=[xn10n+xn110n1++x110+x0100]3=[xn]3[10n]3+[xn1]3[10n1]3++[x1]3[10]3+[x0]3[1]3=[xn]3+[xn1]3++[x1]3+[x0]3=[xn+xn1++x1+x0]3.

Största gemensamma delare [-]

Inverser i Z/nZ [+]

  • Om [m]nZ/nZ och det finns en restklass [j]nZ/nZ så att [m]n[j]n=[1]n, dvs. mjn1 så säger man att [m]n har en invers eller att [m]n är inverterbar i Z/nZ och inversen är [j]n=[m]1n.
  • Om [m]n har en invers så kan man dividera med [m]n för det är samma sak som att multiplicera med [j]n.
  • Om [j]n=[m]1n så finns det ett heltal k så att mj=1+kn. Om nu d|m och d|n så gäller d|(mjkn) dvs. d|1 och därför är d=1. Med andra ord gäller sgd(m,n)=1. Man kan visa att det omvända påståendet också gäller så att [m]n har en invers i Z/nZsgd(m,n)=1.
Obs! [+]

Om p är ett primtal så har alla element i Z/pZ utom [0]p en invers.

Exempel: Studerandenummer [+]
I ett universitet innehåller studerandenumren sex siffror och en kontrollbokstav. En studerande skrev sitt nummer i formen 53x576J där siffran x blev så suddig att den blev oläsbar. Vad är x då kontrollbokstaven J betyder att då det tal som bildas av siffrorna före J divideras med 23 så blir resten 9. Svar [+]
Vi kan skriva talet 53x576 i formen 530576+x1000 och då får vi med de givna uppgifterna [9]23=[530576+x1000]23=[530576]23+[x]23[1000]23=[12]23+[x]23[11]23, eftersom mod(530576,23)=12 och mod(1000,23)=11. Av detta följer att [x]23[11]23=[3]23 och eftersom [11]123=[21]23mod(2111,23)=mod(231,23)=1 så blir [x]23=[3]23[11]123=[3]23[21]23=[63]23=[63+323]23=[6]23, och vi kan dra slutsatsen att x=6 eftersom 0x9.

Euklides algoritm och sgd(m,n) [-]

  • Antag att mn>0.
  • Välj r0=m och r1=n.
  • Bestäm qj och rj så att 0rj<rj1 och rj2=qjrj1+rjj2 och rj1>0.
  • sgd(m,n)=rk1 om rk=0.
Exempel: [+]

När vi räknar ut sgd(291,108) med Euklides algoritm blir resultatet följande: 291=2108+75108=175+3375=233+933=39+69=16+36=23+0 så att sgd(291,108)=3.

Varför fungerar Euklides algoritm? [+]

Om d|rj och d|rj1 så gäller d|rj2 eftersom rj2=qjrj1+rj och det betyder att sgd(rj2,rj1)sgd(rj1,rj). På motsvarande sätt, om d|rj2 och d|rj1 så gäller d|rj eftersom rj=rj2qjrj1 och det innebär att sgd(rj1,rj)sgd(rj2,rj1) och således gäller sgd(rj1,rj)=sgd(rj2,rj1).
Om rk=0 så gäller sgd(rk1,rk)=sgd(rk1,0)=rk1 eftersom d|0 för alla d så att sgd(m,n)=sgd(r0,r1)==sgd(rk1,rk)=sgd(rk1,0)=rk1.   

Euklides algoritm och inverser i Z/nZ [+]

I Euklides algoritm väljer man r0=m, r1=n och sedan räknar man qj och rjj=2,,k med formeln rj2=qjrj1+rj tills rk=0, och då får man rk1=sgd(m,n). Eftersom rk3=qk1rk2+rk1 så gäller sgd(m,n)=rk1=rk3qk1rk2=ak3jrk3+bk3rk2, där alltså ak3=1 och bk3=qk1. Det betyder att sgd(m,n)=ajrj+bjrj+1 åtminstone då j=k3 och om detta gäller också då 1jk3 så kan man i den här ekvationen som sätta in rj+1=rj1qj+1rj som man får ur ekvationen rj1=qj+1rj+rj+1 och då blir resultatet sgd(m,n)=ajrj+bj(rj1qj+1rj)=aj1rj1+bj1rj, där aj1=aj+bj och bj1=bjqj+1. Det betyder att man med induktion kan visa att sgd(m,n)=a0m+b0n.

Om nu sgd(m,n)=1 så gäller [a0]n[m]n=[1]ndvs.[a0]n=[m]1n,[b0]m[n]m=[1]mdvs.[b0]m=[n]1m.

Exempel: Inversen av en restklass [+]
Om vi skall räkna ut [23]167 så bestämmer vi först sgd(67,23) så här: 67=223+2123=121+221=102+12=21+0 För att vi skall kunna uttrycka sgd(67,23) med hjälp av talen 67 och 23 så räknar vi baklänges och utnyttjar de uttryck för 2 och 21 som vi får ur räkningen ovan: sgd(67,23)=1=21102=12110(23121)=1023+1121=1023+11(67223)=11673223 Av det här följer att (32)23=11167 vilket betyder att [(32)23]67=[1]67 vilket i sin tur är ekvivalent med att [23]167=[32]67=[32+67]67=[35]67.
Hur många räkneoperationer behövs då man räknar ut sgd(m,n) och [n]1m med Euklides algoritm? [+]
Vi antar att m>n. I Euklides algoritm väljer vi r0=m, r1=n och sedan räknar vi ut ri och qi så att ri2=qiri1+rii2 tills rK=0 och då får vi rK1=sgd(m,n). För detta behöver vi K1 divisioner.
Vi skall alltså uppskatta hur stor K kan vara och för att göra detta väljer vi x1=1, x2=2 och xj+2=xj+1+xj,j1. Vi vet att rK1x1 och rK2x2 eftersom rK2>rK1. Om vi nu antar att rKixi1ij så får vi, eftersom qKj+11 att rK(j+1)=qKj+1rKj+rKj+1rKj+rKj+1xj+xj1=xj+1. Med stöd av induktionsprincipen ser vi nu att rKjxj för alla j=1,,K.
Vi kan lösa ekvationen () (det är frågan om Fibonaccis ekvation med en aning avvikande indexering) men det är enklare att visa med hjälp av induktion att xj(1+52)j1j1 (Hur? [+])
Genom att notera att x1=1=(1+52)11, x2=2(1+52)21 och att (1+52)j+11+(1+52)j1=(1+52)j+21.
Av detta följer att m=r0xK(1+52)K1, av vilket i sin tur följer att K1log(m)log(1+52), vilket betyder att det behövs O(log(max(m,n))) räkneoperationer för att bestämma sgd(m,n) med Euklides algoritm. Av detta följer också att det behövs O(log(m)) räkneoperationer för att räkna ut [n]1m.
Ett delbarhetsresultat [+]

Om m och n är heltal och p är ett primtal så att mn är delbar med p så är antingen m eller n delbar med p och här är det frågan om hur man kan bevisa detta utan att använda något som stöder sig på det här resultatet.

Varför? [+]

Vi antar att m inte är delbar med p (i annat är ju saken klar). Då gäller sgd(p,m)=1 eftersom p är ett primtal. Med Euklides utvidgade algoritm hittar vi heltal a och b så att ap+bm=1. Vi multiplicerar båda sidorna av denna ekvation med n och får n=n1=nap+bmn. Eftersom mn är delbar med p så finns det ett heltal k så att mn=kp. Av det här följer att n=nap+bkp=(na+bk)p, vilket betyder att n är delbar med p.

Eulers φ-funktion [+]

φ(n)=|{mZ:0mn1,sgd(m,n)=1}|, dvs. φ(n) är antalet element i mängden Z/nZ som har en invers.

Observera att [0]1 har en invers (dvs. [0]1) i mängden Z/1Z så att φ(1)=1 men [0]n har naturligtvis (?) inte någon invers i mängden Z/nZn>1.

I matlab/octave kan man använda funktionen @(n)sum(gcd(0:n-1,n)==1) för att räkna ut värdena av φ.

Exempel: φ(pq)=(p1)(q1)p och q är olika primtal [+]

Eftersom p och q är primtal är mängden {kZ:0k<pq,sgd(k,pq)1} lika med mängden {0}{q,2q,(p1)q}{p,2p,(q1)p} och vi kan se att i den här mängden finns det 1+(p1)+(q1) element. Eftersom det i mängden {0,1,2,,pq1} finns pq element så är φ(pq)=pq(1+(p1)+(q1))=(p1)(q1).

Det här resultatet är ett specialfall av resultatet enligt vilket φ(ab)=φ(a)φ(b) om sgd(a,b)=1.

Eulers sats [+]

Om sgd(a,n)=1 och n>1 så gäller aφ(n)n1dvs.mod(aφ(n),n)=1dvs.[aφ(n)]n=[1]n. I synnerhet, om p är ett primtal och sgd(a,p)=1 så gäller ap1p1elimod(ap1,p)=1eli[ap1]p=[1]p.

Bevis [+]

  • Vi antar att de inverterbara elementen i Z/nZ är [x1]n,,[xϕ(n)].
  • Eftersom sgd(a,n)=1 så har också [a]n en invers och eftersom [α]n[β]n är inverterbar (med inversen [β]1n[α]1n) om [α]n och [β]n är inverterbara så är [a]n[xj] inverterbar för alla j.
  • Om nu [a]n[xj]n=[a]n[xk]n så är [a]1n[a]n[xj]n=[a]1n[a]n[xk]n dvs. [xj]n=[xk]n. Av det här följer att elementen [a]n[x1]n,[a]n[xφ(n)]n är de samma som elementen [x_1]_n,\ldots ,[x_{\varphi(n)}]$ men möjligen i en annan ordning.
  • Men produkterna är lika, dvs. [a]φ(n)nΠφ(n)i=1[xi]n=Πφ(n)i=1([a]n[xi]n)=Πφ(n)i=1[xi]n.
  • Eftersom alla elementen [xi]n är inverterbara kan vi dividera bort alla [xi]n och slutresultatet är att [a]φ(n)n=[1]n dvs. mod(aφ(n),n)=1.

RSA-algoritmen [-]

I RSA-algoritmen använder man en publik nyckel (n,k) för att kryptera ett meddelande och en privat nyckel (n,d) för att dekryptera meddelandet:

  • Kryptering: Meddelandet a, som är ett tal mellan 0 och n1, krypteras b=mod(ak,n) som sänds iväg.
  • Dekryptering: Mottagaren dekrypterar det krypterade meddelandet b det till det ursprungliga meddelandet a=mod(bd,n).

Metoden bygger på att det är (kall vara) oöverkomligt svårt att med hjälp av endast den publika nyckeln (n,k) bestämma den privata nyckeln (n,d) så att vem som helst kan skicka ett meddelande krypterat med mottagarens publika nyckel men endast mottagaren, som känner till sin privata nyckel kan dekryptera det krypterade meddelandet.

Hur skall nycklarna i RSA-algoritmen väljas? [+]
  • n=pq där p och q är två stora primtal så att det är oöverkomligt svårt att faktorisera n i faktorerna p och q (vilket tex. betyder att också |pq| måste vara stort).
  • k är ett stort tal så att 0<k<m och sgd(k,m)=1 där m=(p1)(q1).
  • Med Euklides algoritm bestämmer man d så att [d]m=[k]1m.

Krypteringen baserar sig på att det är svårt att bestämma talet d om man inte känner till m och det i sin tur är svårt om man inte känner till p och q.

Exempel [+]

Om vi vill kryptera meddelandet 9 med RSA-algoritmen och den publika nyckeln (55,23) så skall vi räkna ut mod(923,55). Fastän talen 55 och 23 är alldeles för små för krypteringen är det ändå inte förnuftigt att först räkna m=923 och sedan mod(m,55). I stället konstaterar vi först att 23=16+4+2+1=24+22+21+20923=91694929=(((92)2)2)2(92)2929 och i varje skede kan vi tillämpa mod-funktionen dvs. vi räknar först mod(92,55)=26, sedan mod(94,55)=mod(262,55)=16 osv. så att vi får mod(9j,55)j=1,2,4,8,16. Sedan räknar vi mod(93,55)=mod(992,55)=mod(926,55) och sedan på samma sätt mod(97,55) och mod(923,55). Enklast kan vi gör detta med följande algoritm som räknar ut mod(xy,n):

function z=pmod(x,y,n)
z=1;
x=mod(x,n);
while y > 0
   k=mod(y,2);
   if k == 1, z=mod(z*x,n); end
   y=(y-k)/2;
   if y > 0, x=mod(x*x,n); end
end
return,endfunction

Med den här algoritmen får vi följande mellanresultat när vi räknar ut mod(923,55) dvs. pmod(9,23,55):
k zxy
1923
1 mod(19,55)=9 mod(99,55)=2611
1 mod(926,55)=14 mod(2626,55)=165
1 mod(1416,55)=4 mod(1616,55)=362
0 4 mod(3636,55)=311
1 mod(431,55)=14 310
och det sista z-värdet 14 är det krypterade meddelandet.
Observera att talföljden 10111 som man kan bilda av värdena på k är 23 som binärtal.

För att vi skall kunna dekryptera det det krypterade meddelandet 14 måste vi känna till den privata nyckeln och eftersom 55=511 och (51)(111)=40 så skall vi räkna ut [23]140 och vi får som svar [7]40 vilket vi kan kontrollera genom att räkna mod(237,40)=mod(161,40)=1. Den privata nyckeln är alltså (55,7) och vi skall räkna mod(147,55). Om vi använder samma algoritm som ovan så ser räkningen ut på följande sätt:

k zxy
1147
1 mod(114,55)=14 mod(1414,55)=313
1 mod(1431,55)=49 mod(3131,55)=261
1 mod(4926,55)=9 0

Varför fungerar RSA-algoritmen? [+]
  • Vi antar för enkelhetens skull först att sgd(a,n)=1.
  • φ(n)=φ(pq)=(p1)(q1)=m.
  • Enligt Eulers sats gäller [am]n=[1]n.
  • Eftersom [d]m=[k]1m så är kd=1+rm och [bd]n=[akd]n=[a1+rm]n=[a]n[am]rn=[a]n[1]rn=[a]n, av vilket följer att mod(bd,n)=mod(a,n)=a.

Varför fungerar RSA-algoritmen då sgd(a,n)1? [+]

  • Eftersom vi antar att 0<a<n så gäller sgd(a,n)1 endast om p|a eller q|a. Vi antar att p|a så att a=pjc där sgd(c,n)=1.
  • Nu är [bd]n=[((pjc)k)d]n=[(pk)d]jn[(ck)d]n och eftersom sgd(c,n)=1 så gäller enligt det vi redan visat [(ck)d]n=[c]n och vi skall ännu visa att [(pk)d]n=[p]n för då får vi [bd]n=[p]jn[c]n=[pjc]n=[a]n.
  • Eftersom q är ett primtal så är φ(q)=q1 och eftersom p också är ett primtal och pq så är sgd(p,q)=1 så att det följer av Eulers sats att [pq1]q=[1]q.
  • Då gäller också [p(q1)(p1)r]q=[1]q dvs. p(q1)(p1)r=1+sq och då vi multiplicerar båda sidorna med p så får vi p1+(q1)(p1)r=p+spq=p+sn. Eftersom [d]m=[k]1m så är kd=1+mr=1+(p1)(q1)r och det betyder att [(pk)d]n=[p1+(q1)(p1)r]n=[p]n och algoritmen fungerar också i det här fallet!
RSA-algoritmen och underskrifter [+]

Om A vill skicka meddelande a till B och B vill bli övertygad om att meddelandet verkligen kommer från A så kan de gå tillväga på följande sätt:

  • A räknar ut ett kondensat eller hashvärde h(a) av meddelandet a.
  • A krypterar meddelandet a med B:s publika nyckel (nB,kB) till det krypterade meddelandet b=mod(akB,nB).
  • A krypterar h(a) med sin egen privata nyckel (nA,dA) till en underskrift s=mod(h(a)dA,nA).
  • A skickar b och s till B.
  • B dekrypterar b med sin privata nyckel (nB,dB) och får som resultat a.
  • B räknar ut hashvärdet h(a):n och dekrypterar s med A:s publika nyckel (nA,kA) och om resultatet är samma som h(a) så blir B övertygad om att meddelandet a verkligen kommer från A eftersom ingen annan kan kryptera h(a) med A:s privata nyckel (nA,dA).

Det här baserar sig på att [k]m=[d]1m så kan ett meddelande som krypterats med en privat nyckel dekrypteras med motsvarande publika nyckel.

Exempel [+]

A vill skicka meddelandet 9 till B och lägga till en underskrift så att B kan vara säker på att A verkligen är avsändaren.

Om nu A:s publika RSA-nyckel är (nA,kA)=(91,11), privata nyckel (nA,dA)=(91,59) och på motsvarande vis B:s publika nyckel är (nB,kB)=(55,23) och privata nyckel (nB,dB)=(55,7) och de som hashfunktion använder h(x)=26mod(x(51)/2,1) så utför A och B följande räkneoperationer:

  • A krypterar meddelandet 9 med B:s publika nyckel och får som resultat mod(9kB,nB)=mod(923,55)=14
  • A räknar hashvärdet h(9)=35.
  • A krypterar hashvärdet med sin egen privata nyckel och får som resultat underskriften mod(35dA,nA)=mod(3511,91)=42.
  • A skickar talen 14 och 42 till B.
  • B dekrypterar det krypterade meddelandet 14 med sin egen privata nyckel och får som resultat mod(14dB,nB)=mod(147,55)=9.
  • B räknar ut hashvärdet h(9)=35.
  • B dekrypterar A:s underskrift med A:s publika nyckel och får som resultat mod(42kA,nA)=mod(4259,91)=35.
  • Eftersom resultatet är h(9) kan B lita på att det är A som skickat meddelandet.
    
  

Senast modifierad: G. Gripenberg, 2017-10-09