Talteori och RSA-kryptering
Modulär- eller kongruensaritmetik:
Grundbegrepp och beteckningar [-]
- Delbarhet [-]
Talet
b är delbart med talet
a, dvs.
b är en multipel
av
a, dvs.
a delar talet
b om det finns ett heltal
k så att
b=a⋅k, dvs.
b∈a⋅Z. Detta skrivs också ofta som
a|b.
- Modulofunktionen mod [-]
Om
n>0 så är
mod(m,n)=j ifall
0≤j<n och
m=j+kn där
k∈Z.
Men mod(m,0)=m och mod(m,n)=mod(m,−n)+n när n<0.
Om m och n är positiva heltal så är mod(m,n)
resten som fås när m delas med n men om m<0
så är denna rest inte positiv.
- Kongruens modulo [-]
Talet
a är kongruent med talet
b modulo
n ifall
a−b är
delbart med
n och detta betecknas med
a≡nb eller
a≡b(modn):
a≡nb↔a≡b(modn)↔n|(a−b)↔∃k∈Z(a=b+k⋅n)↔mod(a,n)=mod(b,n)
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,n−1,0,2⋅n−1,n,…},
{…,−n+1,−n+1,n−1,1,2⋅n−1,n+1,…},
⋮
{…,−n+1,−1,n−1,n−1,2⋅n−1,2⋅n−1,…},
i vilka alla element är kongruenta med varandra modulo n.
Följande beteckningar används när n>0:
[k]n={m∈Z:m≡nk}={m∈Z:mod(m,n)=mod(k,n)},Z/nZ={[k]n:k=0,1,2,…,n−1}.
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
a1≡na2ochb1≡nb2
så gäller
(a1+b1)≡n(a2+b2)(a1−b1)≡n(a2−b2)(a1⋅b1)≡n(a2⋅b2)
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=[a−b]n,[a]n⋅[b]n=[a⋅b]n,[a]jn=[aj]n,j∈N0,
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 xnxn−1…x1x0
talet
m=xn⋅10n+xn−1⋅10n−1+…+x1⋅10+x0⋅100.
- [10j]3=[10]j3=[1]j3=[1j]3=[1]3.
- Av detta följer påståendet eftersom
[m]3=[xn⋅10n+xn−1⋅10n−1+…+x1⋅10+x0⋅100]3=[xn]3⋅[10n]3+[xn−1]3⋅[10n−1]3+…+[x1]3⋅[10]3+[x0]3⋅[1]3=[xn]3+[xn−1]3+…+[x1]3+[x0]3=[xn+xn−1+…+x1+x0]3.
Största gemensamma delare [-]
- Om m och n är heltal som inte båda är 0 så
är deras största gemensamma delare
sgd(m,n)=max{d∈Z:d|m och d|n}.
- sgd=största gemensamma delare, gcd= greatest common
divisor, och vanligtvis definierar man
sgd(0,0)=0.
- Om sgd(m,n)=1 så säger man att talen m och n
är relativt prima.
- Observera att det följer av definitionen att
sgd(m,n)=sgd(n,m)=sgd(|m|,|n|).
Inverser i Z/nZ [+]
- Om [m]n∈Z/nZ och det finns en restklass [j]n∈Z/nZ så att [m]n⋅[j]n=[1]n, dvs. m⋅j≡n1 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
m⋅j=1+k⋅n. Om nu d|m och d|n så gäller
d|(m⋅j−k⋅n) 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/nZ↔sgd(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+x⋅1000 och då får vi med de givna uppgifterna
[9]23=[530576+x⋅1000]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]23 då
mod(21⋅11,23)=mod(231,23)=1 så blir
[x]23=[−3]23⋅[11]−123=[−3]23⋅[21]23=[−63]23=[−63+3⋅23]23=[6]23,
och vi kan dra slutsatsen att
x=6 eftersom
0≤x≤9.
Euklides algoritm och sgd(m,n) [-]
- Antag att m≥n>0.
- Välj r0=m och r1=n.
- Bestäm qj och rj så att 0≤rj<rj−1 och
rj−2=qj⋅rj−1+rj
då j≥2 och rj−1>0.
- sgd(m,n)=rk−1 om rk=0.
Exempel: [+]
När vi räknar ut sgd(291,108) med Euklides algoritm blir
resultatet följande:
291=2⋅108+75108=1⋅75+3375=2⋅33+933=3⋅9+69=1⋅6+36=2⋅3+0
så att sgd(291,108)=3.
Varför fungerar Euklides algoritm? [+]
Om
d|rj och
d|rj−1 så gäller
d|rj−2
eftersom
rj−2=qj⋅rj−1+rj och det betyder att
sgd(rj−2,rj−1)≥sgd(rj−1,rj). På motsvarande sätt,
om
d|rj−2 och
d|rj−1 så gäller
d|rj
eftersom
rj=rj−2−qj⋅rj−1 och det innebär att
sgd(rj−1,rj)≥sgd(rj−2,rj−1) och således
gäller
sgd(rj−1,rj)=sgd(rj−2,rj−1).
Om
rk=0 så gäller
sgd(rk−1,rk)=sgd(rk−1,0)=rk−1 eftersom
d|0
för alla
d så att
sgd(m,n)=sgd(r0,r1)=…=sgd(rk−1,rk)=sgd(rk−1,0)=rk−1.
Euklides algoritm och inverser i Z/nZ [+]
I Euklides algoritm väljer man r0=m, r1=n och sedan
räknar man
qj och rj då j=2,…,k med formeln
rj−2=qj⋅rj−1+rj tills rk=0, och då får man
rk−1=sgd(m,n). Eftersom
rk−3=qk−1⋅rk−2+rk−1 så gäller
sgd(m,n)=rk−1=rk−3−qk−1⋅rk−2=ak−3j⋅rk−3+bk−3⋅rk−2,
där alltså ak−3=1 och bk−3=qk−1. Det betyder att
sgd(m,n)=aj⋅rj+bj⋅rj+1 åtminstone då j=k−3 och
om detta gäller också då 1≤j≤k−3
så kan man i den här ekvationen som sätta in
rj+1=rj−1−qj+1⋅rj
som man får ur ekvationen rj−1=qj+1⋅rj+rj+1
och då blir resultatet
sgd(m,n)=aj⋅rj+bj⋅(rj−1−qj+1⋅rj)=aj−1⋅rj−1+bj−1⋅rj,
där aj−1=aj+bj och bj−1=−bj⋅qj+1. Det betyder att
man med induktion kan visa att
sgd(m,n)=a0⋅m+b0⋅n.
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=2⋅23+2123=1⋅21+221=10⋅2+12=2⋅1+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=21−10⋅2=1⋅21−10⋅(23−1⋅21)=−10⋅23+11⋅21=−10⋅23+11⋅(67−2⋅23)=11⋅67−32⋅23
Av det här följer att
(−32)⋅23=1−11⋅67 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
ri−2=qiri−1+ri då i≥2 tills rK=0 och
då får vi rK−1=sgd(m,n). För detta behöver vi K−1
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,j≥1.
Vi vet att rK−1≥x1 och rK−2≥x2 eftersom
rK−2>rK−1. Om vi nu antar att
rK−i≥xi då 1≤i≤j så får vi, eftersom qK−j+1≥1 att
rK−(j+1)=qK−j+1rK−j+rK−j+1≥rK−j+rK−j+1≥xj+xj−1=xj+1.
Med stöd av induktionsprincipen ser vi nu att rK−j≥xj
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)j−1
då
j≥1 (Hur? [+])
Genom att notera att
x1=1=(1+√52)1−1,
x2=2≥(1+√52)2−1 och att
(1+√52)j+1−1+(1+√52)j−1=(1+√52)j+2−1.
Av detta följer att
m=r0≥xK≥(1+√52)K−1,
av vilket i sin tur följer att
K−1≤log(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
m⋅n ä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
a⋅p+b⋅m=1. Vi multiplicerar båda sidorna av denna
ekvation med n och får
n=n⋅1=n⋅a⋅p+b⋅m⋅n.
Eftersom m⋅n är delbar med p så finns det ett heltal
k så att m⋅n=k⋅p. Av det här följer att
n=n⋅a⋅p+b⋅k⋅p=(n⋅a+b⋅k)⋅p,
vilket betyder att n är delbar med p.
Eulers φ-funktion [+]
φ(n)=|{m∈Z:0≤m≤n−1,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/nZ då n>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: φ(p⋅q)=(p−1)⋅(q−1) då p och q är olika primtal [+]
Eftersom p och q är primtal är mängden
{k∈Z:0≤k<p⋅q,sgd(k,p⋅q)≠1}
lika med mängden {0}∪{q,2⋅q,…(p−1)⋅q}∪{p,2⋅p,…(q−1)⋅p} och vi kan se att i den här mängden finns det
1+(p−1)+(q−1) element. Eftersom det i mängden
{0,1,2,…,p⋅q−1} finns p⋅q element så är
φ(p⋅q)=p⋅q−(1+(p−1)+(q−1))=(p−1)⋅(q−1).
Det här resultatet är ett specialfall av resultatet enligt vilket
φ(a⋅b)=φ(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
ap−1≡p1elimod(ap−1,p)=1eli[ap−1]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
n−1, 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=p⋅q 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å |p−q| måste vara
stort).
- k är ett stort tal så att 0<k<m och sgd(k,m)=1 där
m=(p−1)⋅(q−1).
- 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+20 så
923=916⋅94⋅92⋅9=(((92)2)2)2⋅(92)2⋅92⋅9 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)
då j=1,2,4,8,16. Sedan räknar vi mod(93,55)=mod(9⋅92,55)=mod(9⋅26,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 | z | x | y |
| 1 | 9 | 23 |
1 | mod(1⋅9,55)=9 |
mod(9⋅9,55)=26 | 11 |
1 | mod(9⋅26,55)=14 |
mod(26⋅26,55)=16 | 5 |
1 | mod(14⋅16,55)=4 |
mod(16⋅16,55)=36 | 2 |
0 | 4 |
mod(36⋅36,55)=31 | 1 |
1 | mod(4⋅31,55)=14 |
31 | 0 |
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=5⋅11
och (5−1)⋅(11−1)=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(23⋅7,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 | z | x | y |
| 1 | 14 | 7 |
1 | mod(1⋅14,55)=14 |
mod(14⋅14,55)=31 | 3 |
1 | mod(14⋅31,55)=49 |
mod(31⋅31,55)=26 | 1 |
1 | mod(49⋅26,55)=9 |
| 0 |
Varför fungerar RSA-algoritmen? [+]
- Vi antar för enkelhetens skull först att sgd(a,n)=1.
- φ(n)=φ(p⋅q)=(p−1)⋅(q−1)=m.
- Enligt Eulers sats gäller [am]n=[1]n.
- Eftersom [d]m=[k]−1m så är k⋅d=1+r⋅m och
[bd]n=[ak⋅d]n=[a1+r⋅m]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=pj⋅c där sgd(c,n)=1.
- Nu är [bd]n=[((pj⋅c)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=[pj⋅c]n=[a]n.
- Eftersom q är ett primtal så är φ(q)=q−1 och
eftersom p också är ett primtal och p≠q så är
sgd(p,q)=1 så att det följer av Eulers sats att
[pq−1]q=[1]q.
- Då gäller också [p(q−1)(p−1)r]q=[1]q dvs.
p(q−1)(p−1)r=1+sq och då vi multiplicerar båda sidorna med
p så får vi p1+(q−1)(p−1)r=p+spq=p+sn.
Eftersom [d]m=[k]−1m så är k⋅d=1+mr=1+(p−1)(q−1)r
och det betyder att [(pk)d]n=[p1+(q−1)(p−1)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)=⌊26⋅mod(x⋅(√5−1)/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