1. No category

Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Kryptografi med Elliptiske kurver
med perspektiv til Suite B
CHRISTEL BACH
KRYPTOLOGI C, MASTERPROJEKT, 2010
MASTER I KRYPTOLOGI
ÅRHUS UNIVERSITET
1
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Kryptografi med Elliptiske kurver
med perspektiv til Suite B
CHRISTEL BACH
Forord
31. juli 2010
Nærværende materiale er skrevet som afsluttende opgave i forbindelse med Master i
Kryptologi, Kryptologi C, Århus Universitet, mellem 2006 og 2010. Det er desuden
med visse modifikationer eventuelt tænkt anvendt i en undervisningssammenhæng i
forbindelse med modulet ’Security’ til uddannelserne Professionsbachelor Software
Udvikling og Professionsbachelor Web Udvikling. Bekendtgørelsen for dette modul
kan ses i bilag C2. Det ligger dog uden for modulets kerneområder og vil være at
betragte som emne for særligt interesserede. Der vil derfor være både
grundlæggende forklaringer, og referencer til videre studier af emnet.
01.oktober 2010.
Denne version 1.4 indeholder flere smårettelser samt udvidede eksempler på pohlighellmann angreb, complex multiplikation o.a. samt et par ekstra bilag, alt sammen
udarbejdet til master forsvaret der fandt sted 28.09.2010.
Desuden er et par åbenlyse matematiske fejl og protokol fejl i version 1.0 af denne
opgave, påvist ved forsvaret , rettet og skrevet om.
Tak til mine børn for at have udholdt lange perioder med alt for meget fokus på
masteruddannelsen. Tak til mine kolleger for aldrig at tvivle. En særlig tak til Niels og
Marlene.
2
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Indhold
FORORD............................................................................................................................. 2
1.
INTRODUKTION ......................................................................................................... 6
2.
ELLIPTISKE KURVER OVER ENDELIGE LEGEMER FP....................................................... 7
3.
ELLIPTISKE KURVER OVER DET ENDELIGE LEGEME F2M ................................................ 8
4.
ECDLP, ELLIPTISK KURVE DISKRET LOGARITME PROBLEM .......................................... 9
5.
EGNEDE OG UEGNEDE KURVER OG DOMÆNEPARAMETRE ........................................ 9
DISKRIMINANTEN....................................................................................................................... 9
SUPERSINGULÆRE KURVER ........................................................................................................ 10
ANORMALE KURVER ................................................................................................................. 10
ANORMALE BINÆRE KURVER – KOBLITZ KURVER............................................................................ 10
BINÆRE LEGEMER AF SAMMENSAT ORDEN ................................................................................... 10
NÆSTEN PRIMTALSORDEN ......................................................................................................... 10
BASEPUNKTET SOM GENERATOR ................................................................................................. 10
PSEUDO-RANDOMISERING......................................................................................................... 11
DOMÆNEPARAMETER GENERERING OG VALIDERING ...................................................................... 11
ANBEFALINGER OG NIST ........................................................................................................... 11
6.
ANTAL PUNKTER PÅ KURVEN ................................................................................... 12
HASSES SÆTNING ..................................................................................................................... 12
3
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
ANTALLET AF PUNKTER PÅ BINÆRE KURVER #𝑬𝑬(𝑭𝑭𝟐𝟐𝒎𝒎 ) ............................................................... 13
SCHOOFS ALGORITME ............................................................................................................... 13
KOMPLEKS MULTIPLIKATION (CM) METODE ................................................................................. 14
COMPLEX MULTIPLIKATION – GENNEMREGNET EKSEMPEL ............................................................... 14
7.
ANGREB - MÅDER AT FINDE N FOR NP= Q ................................................................ 15
WEIL PAIRRING OG MOV ATTACK .............................................................................................. 16
POLLARDS RHO METODE ........................................................................................................... 17
POHLIG – HELLMAN METODE..................................................................................................... 17
POHLIG-HELLMANN ANGREB GENNEMREGNET.............................................................................. 18
8.
SUITE B .................................................................................................................... 19
NIST ANBEFALINGER ................................................................................................................ 20
Legemer ...............................................................................................................20
OPTIMERING PÅ NIST KURVER – NUMERISK EKSEMPEL .................................................................. 21
Matematiske rutiner på p192 ..............................................................................21
Det ses altså at være langt enklere at regne via de optimerede rutiner. ...........22
Binære legemer....................................................................................................22
NIST kurver ...........................................................................................................22
Valg af reduktionspolynomium............................................................................22
9.
GENERERING OG VERIFIKATION AF DOMÆNE PARAMETRE ..................................... 23
VERIFIKATION.......................................................................................................................... 24
Sha1 hashing af hexværdier .................................................................................26
Verifikation af P-192 ............................................................................................27
Yderligere verifikationsovervejelser: ...................................................................29
Eksempel - At konstruere r for P-224 ..................................................................29
Test af domæneparametre for P-224: .................................................................30
Test af domæne parametre for P-521 ................................................................31
10.
IMPLEMENTATIONSOVERVEJELSER: ...................................................................... 32
STORE TAL - BIGINTEGERS ......................................................................................................... 32
MODULÆR MULTIPLIKATIV INVERS .............................................................................................. 33
KVADRATRØDDER MODULUS P IMPLEMENTATION ......................................................................... 34
PUNKTET I UENDELIG - HOMOGENE KOORDINATER ....................................................................... 37
‘DOUBLE AND ADD’ ALGORITME ................................................................................................. 38
Hurtig potensopløftnings algoritmen ..................................................................38
11.
KRYPTOGRAFISK ANVENDELSE AF ELLIPTISKE KURVER .......................................... 39
PRINCIPPER BAG ELLIPTIC DIFFIE-HELLMAN NØGLE UDVEKSLING ...................................................... 39
Eksempel på Diffie-Hellman nøgleudveksling med P-192 ...................................39
PRINCIPPER BAG EC ELGAMAL PUBLIC KEY KRYPTOSYSTEM ............................................................ 40
At repræsentere klartekst med punkter på elliptiske kurver ..............................41
MV ELGAMAL - MENEZES – VANSTONE VARIANTEN AF ELGAMAL ................................................... 44
Beskedudvidelse: .................................................................................................45
Eksempel: .............................................................................................................45
Fra klartekst til ASCII værdier og fra ASCII til klartekst ........................................47
4
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
ECDSA – DIGITAL SIGNATUR MED ELLIPTISKE KURVER ................................................................... 49
Lille ECDSA eksempel ...........................................................................................50
ECDSA eksempel med P-192 ................................................................................51
12.
IMPLEMENTATION AF MV ELGAMAL ECC .............................................................. 52
13.
PAKKELØSNINGER, BIBLIOTEKER OG ANDRE IMPLEMENTATIONER ....................... 54
ILLUSTRATIVE IMPLEMENTATIONER AF KRYPTOGRAFI MED EC .......................................................... 54
SUPPORT AF SUITE B I .NET ...................................................................................................... 55
ANDRE LØSNINGER - BOUNCY CASTLE ......................................................................................... 55
14.
ECC VERSUS RSA ................................................................................................... 55
15.
DANSKE STANDARDER PÅ OMRÅDET FOR DIGITAL SIGNATUR OG SIKKER
KOMMUNIKATION: .......................................................................................................... 56
16.
AFRUNDING OG KONKLUSION .............................................................................. 57
EFTERSKRIFT ........................................................................................................................... 57
17.
LITTERATUR HENVISNINGER ................................................................................. 59
18.
OVERSIGT OVER BILAG: ........................................................................................ 60
19.
ECC
KILDEKODE TIL IMPLEMENTATION AF ELLIPTISK KURVE KRYPTOGRAFI MV ELGAMAL
60
20.
Kryptering og dekryptering af beskeder med NIST kurver baseret på
primlegemer og kurven Y^2=X^3+AX+B i C#.NET ..............................................60
SUPPLERENDE PÆDAGOGISKE MATEMATISKE BILAG ............................................ 73
Kort oversigt over algebraiske strukturer: ...........................................................73
Homomorfi – endomorfi -isomorfi ......................................................................74
Afbildinger ............................................................................................................74
Grundlæggende om Elliptiske kurver ..................................................................75
Diskriminanten og singulære punkter .................................................................78
Mathematica visualisering ...................................................................................79
Punktaddition på R – kode eksempel i javascript ................................................80
Multiplicativ invers modulus p - kodeeksempel i javascript ...............................81
ElGamal og DLP ....................................................................................................82
Kvadratroden af store tal .....................................................................................83
RSA protokol og implementation ........................................................................83
Tidskomplexitet med regneeksempler på elliptiske kurver ................................88
MIPS – antal millioner instruktioner pr sekund ...................................................88
Eksempel: At lede efter kvadrattal ......................................................................89
Eksempel: Antallet af punkter der beregnes med Schoofs algoritme tidskompleksitet ..................................................................................................89
Eksempel – Pollards Rho metode: .......................................................................89
Kan man lave en tabel over tP på en NIST kurve? ...............................................90
21.
5
ØVRIGE BILAG: ..................................................................................................... 90
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Danske standarder ...............................................................................................90
Studieordning.......................................................................................................92
1. Introduktion
Grundlæggende indføring i emnet elliptiske kurver over R er inkluderet i bilag B2.
Man vil også kunne se en visualisering af elliptiske kurver hos wolfram.com 1
Et lille demonstrationseksempel på punktaddition i R er vedlagt som i kildekode i
bilagB5. Da der vil blive anvendt algebraisk terminologi er der i bilag B1 en kort
oversigt over algebraiske strukturer
Ved kryptografisk anvendelse af elliptiske kurver(EC) anvendes elliptiske kurver over
endelige legemer.
Denne gennemgang vil være organiseret således at grundlæggende egenskaber for
kurver over endelige legemer først gennemgås, herunder forskellige typer af
legemer og overvejelser omkring valg af basis i relation til implementation. Herefter
præciseres forudsætninger for hvilke kurver der er egnet til kryptografisk brug
De i Suite B anbefalede såkaldte NIST kurver og domæneparametre vil blive
gennemgået, diskuteret og forsøgt verificeret via forskellige metoder.
Efterfølgende vil en række protokoller for klassiske kryptografiske anvendelser af EC
blive gennemgået. I denne forbindelse vil jeg diskutere og vise forskellige
implementationsovervejelser til demonstrationsbrug og give eksempler på disse.
Implementationerne vil IKKE være egnet til industristandard og tjener primært
illustrative og pædagogiske formål.
Kodeeksempler vil primært være programmeret i C#.NET og alle vedlagte eksempler
kan afprøves på http://www.christelbach.com
En hel anden anvendelsesdimension af elliptiske kurver, nemlig Lenstra’s Elliptiske
Kurve Metode(ECM) til primtalsfaktorisering vil ikke blive berørt da det var emnet
for min eksamensopgave i modulet KryptologiB 2
1
2
http://demonstrations.wolfram.com/RealEllipticCurves/
http://christel.dk/krypto/Den_elliptiske_faelde-kopi.pdf
6
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
2. Elliptiske kurver over endelige legemer Fp
Til kryptografisk brug betragter vi punkter P og Q på en elliptisk kurver over et
endeligt legeme. Vi knytter regneoperationer på disse punkter der gør E(Fp) til en
gruppe.
Et endeligt legeme består af et endeligt sæt af elementer F med to tilhørende
operationer kaldet multiplikation og addition.
Legemets orden er antallet af elementer i legemet.
Antallet af elementer i et endeligt legeme er altid en primtalspotens pn. Skal ordenen
være et primtal har vi altså n=1
For ethvert primtal p og positivt heltal n, eksisterer der et endeligt legeme med pn
elementer. To endelige legemer med samme orden er isomorfe. Legemet betegnes
𝔽𝔽𝑝𝑝 hvis ordenen er et primtal og 𝔽𝔽𝑝𝑝 𝑛𝑛 hvis ordenen er en primtalspotens.
Man ser også betegnelsen 𝐺𝐺𝐺𝐺𝑝𝑝 𝑛𝑛 da disse legemer også kan kaldes Galois legemer.
Har vi et legeme 𝔽𝔽𝑝𝑝 𝑛𝑛 kaldes p da karakteristikken af legemet og n kaldes
udvidelsesgraden.
Vi ser på legemer hvor karakteristikken er et primtal p større end 3.
En elliptisk kurve over 𝔽𝔽𝑝𝑝 er defineret som
𝐸𝐸(𝔽𝔽𝑝𝑝 ) = �(𝑥𝑥, 𝑦𝑦): 𝑥𝑥, 𝑦𝑦 ∈ 𝔽𝔽𝑝𝑝 ℎ𝑣𝑣𝑣𝑣𝑣𝑣 𝑦𝑦 2 = 𝑥𝑥 3 + 𝐴𝐴𝐴𝐴 + 𝐵𝐵� ∪ {𝒪𝒪}
hvor diskriminanten 4A3 + 27B2 er forskellig fra nul og A og B ligger i Fp. Betegnelsen
𝒪𝒪 er det neutrale element – identiteten. Kaldes også punktet i uendeligt.
Vi har en række additionslove der gælder på en sådan kurve
Der gælder at P + 𝒪𝒪= 𝒪𝒪+ P = P. Der gælder ligeledes at addition af punkter P+Q = Q+P
= R, hvor både P og Q ligger i 𝐸𝐸(𝔽𝔽𝑝𝑝 ) giver et nyt punkt R der også ligger i 𝐸𝐸�𝔽𝔽𝑝𝑝 �. Man
kan desuden vise at punktaddition er associativ. Dvs. at vi har (P+Q)+ R = P + (Q+R).
Vi har yderligere at alle punkter har et inverst element ’-P’ således at P + (-P) = 𝒪𝒪.
Dermed er kravene opfyldt for at 𝐸𝐸(𝔽𝔽𝑝𝑝 ) er en endelig gruppe.
Vi definerer k*P som P+P+P+…+P – i alt k P’er lagt sammen med punkt addition.
7
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
3. Elliptiske kurver over det endelige legeme F2m
Mange standarder for elliptisk kurve kryptografi forlanger at p enten er et ulige
primtal eller at pm = q er en potens af 2, altså 2𝑚𝑚 . 𝐹𝐹2𝑚𝑚 kaldes også binære legemer.
Elliptiske kurver over binære legemer vælges på formen
Nonsupersingulær:
𝑦𝑦 2 + 𝑥𝑥𝑥𝑥 = 𝑥𝑥 3 + 𝐴𝐴𝑥𝑥 2 + 𝐵𝐵 hvor A er 0 eller 1, B!=0,
Eller supersingulær:
𝑦𝑦 2 + 𝑦𝑦 = 𝑥𝑥 3 + 𝐴𝐴𝑥𝑥 + 𝐵𝐵 . Vi skal dog senere se at den supersingulære version ikke kan
anvendes til kryptografisk brug og man vil derfor udelukkende bruger kurver på den
nonsupersingulære form.
Koblitz har foreslået en metode hvor man bruger en elliptisk kurve over F2 (der jo ikke
indeholder mere end 4 punkter) mens man lader punkterne ligge på E over 𝐹𝐹2𝑚𝑚 for et
primtal m. Det betyder at man ved at anvende en såkaldt ’frobenius mapping’ (der er en
homomorfi af 𝐸𝐸(𝐹𝐹2𝑚𝑚 ) på sig selv) kan få lette regneoperationer og ikke mindst let kan
beregne antallet af punkter på kurven.
Disse kurver kaldes Koblitz kurver eller anormale binære kurver.
En af årsagerne til at man er særligt interesseret i denne gruppe 𝐸𝐸(𝐹𝐹2𝑚𝑚 ) er desuden at især
punkt dobling er simpel i det tilfælde.
Implementationsmæssigt gør det en stor forskel hvor lang tid de enkelte processer
tager og hvor mange iterationer der skal til.
I en guide 3 til implementation findes en række eksempler på hvordan punktaddition
og skalarmultiplikation kan optimeres på binære legemer.
𝐹𝐹2𝑚𝑚 kan beskrives med såvel polynomial basis som normal basis.jf.[3]
Dette kan også betragtes som et binært endeligt legeme der kan ses som et vektor rum af
m'te dimension over legemet F2, der består af elementerne 1 og 0. Dvs. elementerne i 𝐹𝐹2𝑚𝑚
kan skrives på formen 𝑎𝑎0 𝛼𝛼0 + 𝑎𝑎1 𝛼𝛼1 + 𝑎𝑎2 𝛼𝛼02 + ⋯ + 𝑎𝑎𝑚𝑚 −1 𝛼𝛼𝑚𝑚 −1 hvor 𝑎𝑎𝑖𝑖 ∈ {0,1}
Vi har altså en basis {𝛼𝛼0 , 𝛼𝛼1 , 𝛼𝛼2 , … , 𝛼𝛼𝑚𝑚 −1 }
af 𝐹𝐹2𝑚𝑚 over 𝐹𝐹2
Polynomial basis repræsentation , Reduktionspolynomium
Et irreducibelt polynomium af grad m over 𝐹𝐹2 definerer en polynomial basis
repræsentation af 𝐹𝐹2𝑚𝑚
Et ireducibelt polynomium af grad m over F2 kan ikke faktoriseres op som et produkt af to
polynomier af lavere grad. Et sådant polyomium kan skrives på formen 𝑓𝑓(𝑥𝑥) = 𝑥𝑥 𝑚𝑚 +
𝑡𝑡𝑚𝑚 −1 𝑥𝑥 𝑚𝑚 −1 + ⋯ + 𝑡𝑡2 𝑥𝑥 2 + 𝑡𝑡1 𝑥𝑥 + 𝑡𝑡0 hvor 𝑡𝑡𝑖𝑖 ∈ {0,1} for i=0,1,2…m-1.
3
Companion document Mathematical Routines for NIST Prime Elliptic Curves
8
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Elementer i legemet:
Det endelige legeme 𝐹𝐹2𝑚𝑚 betsår af alle polynomier af grad mindre end m. Dette kan skrives
således:
𝐹𝐹2𝑚𝑚
= �𝑎𝑎𝑚𝑚 −1 𝑥𝑥 𝑚𝑚 −1 + ⋯ + 𝑎𝑎1 𝑥𝑥 + 𝑎𝑎0
∶ 𝑎𝑎𝑖𝑖 ∈ {0,1}�
Vi kan for det enkelte element 𝑎𝑎𝑚𝑚 −1 𝑥𝑥 𝑚𝑚 −1 + ⋯ + 𝑎𝑎1 𝑥𝑥 + 𝑎𝑎0 anvende den kortere form
(𝑎𝑎𝑚𝑚 −1 … 𝑎𝑎1 𝑎𝑎0 ). Altså en bitstreng af længde m.
Vi får altså dermed bitstrenge og dette er implementationsmæssigt nyttigt ved operationer
på elementer i legemet.
Vi kan f. eks repræsentere elementerne i 𝐹𝐹24 således
0000, 0001, 0010, 0011, 0100, 0101, 0110, 0111, 1000, 1001, 1010, 1011, 1100,
1101, 1110, 1111.
Polynomiumsdivisions eksempel
(x6 + x5 + x2+1) mod (x4+x+1) = x3+x2+x+1 fordi (x6 + x5 + x2+1) divideret med (x4+x+1)
er lig med x2+x med rest x3-x2-x+1
4. ECDLP, Elliptisk kurve diskret logaritme problem
Digital signatur og andre kryptografiske protokoller med elliptiske kurver er baseret på det
underlæggende antagne svære problem, at beregne det såkaldte diskrete logaritmeproblem
for elliptiske kurver.
Dette problem kan kort beskrives således:
Givet en elliptisk kurve over et endeligt legeme 𝐹𝐹𝑞𝑞 , et punkt P på kurven af orden n,
𝑃𝑃 ∈ 𝐸𝐸(𝐹𝐹𝑞𝑞 )
og et andet punkt på kurven 𝑄𝑄 = 𝑡𝑡𝑡𝑡 hvor 0 ≤ 𝑡𝑡 ≤ 𝑛𝑛 − 1
Find t.
Det er ikke trivielt på det endelige legeme at beregne hvordan et punkt er et resultat af en
ukendt skalar multiplikation af et andet punkt.
5. Egnede og uegnede kurver og domæneparametre
Når vi evaluerer en kurves egnethed og det legeme hvorpå den er defineret i forhold
til kryptografisk brug, er der især to parametre vi er interesseret i. Den ene er hvor
hurtig den er at regne på – af hensyn til performance, og den anden er eventuelle
egenskaber ved konstruktionen der gør det sårbart over for angreb. Men der er også
helt grundlæggende egenskaber for at vi overhovedet kan få veldefinerede grupper
med konsistente additionslove. Vi har desuden til kryptografisk brug behov for et
basispunkt G
Diskriminanten
Helt grundlæggende må diskriminanten på kurven ikke være 0.
9
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Er diskriminanten 0 svarer det til at flere rødder er ens. Hvis vi skriver højre side på
kurven på formen X3 + AX + B som produktet af dets rødder (X-r1)(X-r2)(X-r3)
(kan også være komplekse rødder) så er diskriminanten D= 4A3+27B2≠0 hvis og kun
hvis rødderne r1,r2 og r3 er forskellig.
Hvis de ikke er forskellige har kurven såkaldte singulære punkter og det går galt med
additionslovene hvis der findes sådanne punkter. Se evt. bilag B3.
Supersingulære kurver
En familie af kurver hvis orden, dvs. antallet af punkter på kurven, er
#E(Fp)=p+1.
Disse kurver har vist sig særligt sårbare over for angreb, herunder det såkaldte MOV
angreb og kan ikke bruges til kryptografisk brug. Supersingulære kurver over binære
legemer har som tidligere nævnt formen 𝑦𝑦 2 + 𝑦𝑦 = 𝑥𝑥 3 + 𝐴𝐴𝑥𝑥 + 𝐵𝐵 .
Anormale kurver
En kurve kaldes anormal hvis dets orden et primtal p er af samme størrelse som det
underlæggende legeme Fp , altså #E(Fp)=p. Der findes en hurtig metode jf. [9] s 328
til at løse ECDLP på kurver af en sådan orden.
Anormale binære kurver – Koblitz kurver
Kurver over F2m er, som før nævnt i modsætning til anormale kurver over Fp, meget
attraktive pga. af de effektive muligheder for fx addition.
Binære legemer af sammensat orden
Kurver over binære legemer af orden 2m hvor m er et produkt af to primtal har vist
sig sårbare over for et angreb ved hjælp af en såkaldt ’Weil Descent’ og skal derfor
også undgås til kryptografisk brug.
Næsten primtalsorden
Hvis antallet af punkter på kurven er et produkt af små primtal er systemet sårbart
over for Pohlig-Hellman angreb.jf [4] s 183. Det betyder at #E(Fp) skal være divisibel
med et tilstrækkeligt stort primtal, altså at ordenen er et primtal (forskellig fra p)
eller et såkaldt næsten-primtal tal s hvor faktorerne er q*n for n meget lille , fx 1,2,3
eller 4 og q større end 2^160 iflg. [5]. Desuden må s ikke dele qk-1 for k mindre end
20.
Basepunktet som generator
Basepunktet G behøver iflg. Koblitz [4]strengt taget ikke være en generator for
gruppen, men skal kunne generere en undergruppe hvor det diskrete
logaritmeproblem ikke er nemt. Det er tilfældet hvis ordenen af punktet G er et
næsten primtal, dvs. kan deles med et primtal der er sammenligneligt med #E(Fp) .
Hvis vi sørger for at #E(Fp) er et stort primtal vil ethvert punkt på kurven (på nær 𝒪𝒪)
være en generator .
10
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Pseudo-randomisering
For at fremtidssikre ECC systemer skal domæneparametrene udvælges
randomiseret. Det vil her sige så randomiseret som en computer nu er i stand til.
Med andre ord skal udfaldene statistisk set fordele sig jævnt uden sporbare mønstre.
Det kalder vi pseudo-randomiseret. Randomiseringen sikrer dels mod at
parametervalg vil være blandt eventuelle fremtidige fundne særligt sårbare
parametre, men det vil også statistisk set gøre sårbarhed overfor forskellige allerede
kendte angrebstyper ubetydelig. Efterfølgende kan man så undersøge om de
tilfældigt udvalgte parametre lever op til ovenstående.
Tilfældigheden vil også sikre at parametrene og de valgte kurver ikke er konstrueret
så de med fuldt overlæg indeholder skjulte sårbarheder der bagefter kan bruges af
konstruktøren.
Randomiseringen skal være bevislig og af kryptografisk valid kvalitet.
Domæneparameter generering og validering
Disse ovenstående forudsætninger skal altså være opfyldt for at kurver og øvrige
domæneparametre er velegnede til kryptografisk brug. En algoritme til sikring af at
disse forudsætninger er til stede kan bl.a. ses i artiklen [14]af bl.a. Johnson, Menezes
og Vanstone. Det er ligeledes en integreret del af FIPS-186-3 standarden at domæne
parametre skabes og valideres efter specifikke algoritmer. Mere herom under Suite
B.
Anbefalinger og NIST
Ifølge Rosing [4]er de kurver der er mest velegnede til kryptografisk brug, kurver
over binære Galois legemer. Dvs. kurver på F2n, med andre ord kurver med
karakteristikken 2, og udvidelsesgraden n, og det da kun hvis de ikke er
supersingulære. De skal altså være af formen:
y2 + xy = x3 + Ax2 + B, B må ikke være nul., A kan godt være nul.
Som det vil fremgå under relevant afsnit er de anbefalede såkaldte NIST kurver
repræsenteret både med Koblitz kurver og random kurver på binære legemer men
også kurver på kort Weierstrass form på primlegemer. Man vil bemærke i
specifikationen til disse at udvidelsesgraden på de binære legemer netop er et
primtal. Ligeledes er antallet af punkter på kurverne angivet for kurver over
primlegemer og de ses at være forskellige fra p og p+1.
Som vi vil se senere er det let at beregne antallet af punkter på binære legemer.
Også antallet af punkter på NIST kurverne over de binære legemer vil vise sig at være
forskellig fra p og p+1.
Det er nu oplagt at det er vigtigt at tjekke antallet af punkter på kurven før den kan
erklæres egnet til kryptografisk brug.
11
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
6. Antal punkter på kurven
Som nævnt har vi behov for at kende gruppen orden, det vil sige antallet af punkter
på kurven for at sikre at dette antal lever op til ovennævnte betingelser for ikke at
gøre systemet sårbart. Punkttælling er et stort genstandsområde inden for
kryptologi.
Har vi en elliptisk kurver på kort Weierstrass form mod p vil vi ved gennemløb af x
værdier for x=0 til x=p-1 løbe igennem antallet af mulige punkter på kurven. Alle de
værdier for S, hvor S= x3-Ax+B, x = 0,1,2,…p-1, som giver et kvadrattal, giver da
punkterne på kurven.
Da cirka halvdelen af alle heltal er kvadrattal modulus p (jf. senere afsnit om
Kvadratisk rest ), og der for hvert kvadrattal findes to løsninger y og -y, vil antallet af
punkter på kurven ikke være meget forskellig fra p. Hasse indkredser det lidt mere
præcist med denne sætning
Hasses sætning
Antallet N af punkter på en kurve E, #E(Fp) vil være inden for intervallet
#E(Fp)=p+1-t hvor |t|<= 2*sqrt(p)
Eksempel
Vi kan da straks f. eks udtale os om antallet at punkter på f. eks E(Fp) hvor
p=6277101735386680763835789423207666416083908700390324961279
Altså er #E(Fp) = 6277101735386680763835789423207666416083908700390324961290-t
hvor| t|<2*sqrtp(p),
At beregne kvadratroden af et stort tal kræver nærmere overvejelser da der ikke er
indbygget en kvadradrodsmetode i BigInteger i C#.
En genvej kan være at beregne e^log(p)/2
Math.Exp(BigInteger.Log(p) / 2)
Problemet er at det ikke giver et præcist tal men blot 7,922816251426 * 1028
En implementation kunne være baseret på Newton Raphson metoden, hvor vi beregner
kvadratroden som en rekursiv beregning over g af (n/g + g)/2. Koden kan ses i bilag B7.
Denne algoritme kan ikke beregne kvadratroden af et tal mod p, her er der behov for andre
overvejelser. Dette er vist i afsnit om dette emne side: 34
Et kommercielt API ’Extreme.Numerics’ tilbyder alternativt en ekstrem let løsning med
using Extreme.Mathematics;
BigInteger calc = BigInteger.Sqrt(p);
Kvadratroden af p afrundet til nærmeste hele tal giver: 79228162514264337593543950336
vi har da at| t|< 158456325028528675187087900670
Dvs antallet af punkter skal iflg. Hasse ligge mellem p+1-t og p+1+t
6277101735386680763835789423049210091055380025203237060610 og
6277101735386680763835789423366122741112437375577412861950
Anvender vi en standardiseret NIST kurve (jf. senere afsnit om Suite B) er antallet af punkter
på kurven allerede givet:
12
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
I specifikationen er dette tal r givet som:
6277101735386680763835789423176059013767194773182842284081
Hvilket ses netop at ligge pænt i dette interval.
Selv om t har en betragtelig størrelse er det meget mindre end p der eksponentielt er i
ordnen 6,3*1057 hvor t eksponentielt kan skrives: 1,6*1029
Hasses sætning giver et resultat der naturligvis stadig er ret upræcist, hvis vi har behov for at
finde det helt nøjagtige antal punkter.
Det er klart at man kan gennemløbe alle mulige x værdier og lede efter matchende
kvadrattal. Det er en meget ineffektiv algoritme der løses i tiden O(p)
Antallet af punkter på binære kurver #𝑬𝑬(𝑭𝑭𝟐𝟐𝒎𝒎 )
På Koblitz kurver hvor A=0 har vi iflg. [9] s 313, nemme udregninger af antal punkter
på kurven. Det kan findes som #E(F2k) = 2k + 1 - ((-1+sqrt(-7))/2)k - ((-1-sqrt(-7))/2)k
hvor de to parenteser repræsenterer komplekse rødder i polynomiet Z2+Z + 2. Altså
en meget let måde at beregne gruppens orden.
Eksempel:
#E(F243)= 2^43 + 1 - ((-1+sqrt(-7))/2)^43 - ((-1-sqrt(-7))/2)^43= 8796092023492
På E(F2163) har vi et resultat der let beregnes i fx Maple således: simplify(2^163 + 1 ((-1+sqrt(-7))/2)^163 - ((-1-sqrt(-7))/2)^163)
#E(F2163)= 11692013098647223345629473816263631617836683539492
for k=233 er antallet af punkter:
13803492693581127574869511724554051042283763955449008505312348098965372
for k= 283
er antallet af punkter:
15541351137805832567355695254588151253139246935172245297183499990119263318
817690415492
for k=409 er antallet af punkter:
13221119375804971979038306160655420796568093659285624385692975800915228451
56996764202693033831109832056385466362470925434684
for k=571 er antallet af punkter
77290750460345166893907037818639746885978546594128699973144705029030382845
79120849072535914090826847338826851203301405845094699896266469247718729686
468370014222934741106692
Schoofs algoritme
En af de mest almindelige metoder til punkttælling er Schoofs algoritme. Den kan
beregne antallet af punkter i tiden O((log p)^6) – altså en polynomial tids algoritme.
Algoritmen er siden blevet optimeret af en række personer og denne kaldes SEA
algoritmen. Den grundlæggende ide er at forsøge at finde antallet af punkter på
kurven modulus t for tilstrækkeligt mange små t og så rekonstruere den ønskede
orden ved hjælp af den kinesiske restsætning. Det er uden for denne opgaves
13
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
område at dykke nærmere ned i Schoofs algoritme. Man vil kunne se flere detaljer i
[6]s 351.
Kompleks multiplikation (CM) metode
En anden tilgang til problemet er at vælge ordenen først og så generere en kurve
med denne orden. Det er fx muligt via den såkaldte ’kompleks
multiplikationsmetode’ CM.
Ideen er jf. [14] følgende: vi lader E være en elliptisk kurve af orden N over Fq. Vi beregner et
Z=4q-(q+1-N)2 og omskriver dette til DV2 hvor D skal være kvadratfrit. Man siger da at kurven
E har kompleks multiplikation med D. Kender kan D for en given kurve kan man effektivt
beregne kurvens orden.
CM metoden giver en måde hvorpå man først konstruerer et D for hvilket der eksisterer et E
over Fq, med en orden der er et næsten-primtal N , altså produktet n*h af et stort primtal n
og et meget lille h forskellig fra 1, og dermed at N er forskellig fra q. Yderligere må n ikke
dele qk – 1 for k mellem 1 og 20. Herfra vil koefficienterne i kurven kunne konstrueres.
Metoden er kun velegnet for små værdier af D.
Til gengæld skulle metoden være særdeles velegnet netop for disse værdier, og overgår i
effektivitet langt punkttælling på kurver over primlegemer for legemer af størrelsesordnen
160 bit, mens metoden ikke kan konkurrere med andre metoder på kurver over binære
legemer. Jf [5]s 179
Detaljerede algoritmer er givet i IEEE-1386 [13] Jeg har kun en version draft 14 tilgængelig og her er
metoden sammensat af følgende algoritmer.
Processen er først at finde en relevant værdi for D, dernæst at finde en nær-primtalsorden 4 for
kurven og slutteligt at konstruerer kurve og punkt. Altså først findes et kvadratfrit D der kan være CM
diskriminant for p.
I [13] afsnit A.14.2.2 har vi en algoritme for test af CM diskriminanter.
A.14.2.3. Indeholder en algoritme til at finde en nær-primtals orden
I A14.2 følger en algoritme til, ud fra ovenstående output, at konstruere en kurve med de ønskede
egenskaber.
Anvendes CM metoden over GF(p) kaldes den da også Atkin-Morain metoden.
Der findes en rigtig fin detaljeret og praktisk gennemgang af metoden og de nødvendige
mellemregninger med gode eksempler i [6] ss. 358-368
Complex multiplikation – gennemregnet eksempel
Det er som nævnt muligt at vælge en ønsket orden, N=h*r og herefter legeme. h er en lille
cofakor og r et stort primtal (jf Pohlig-Hellman angrebet). Der skal findes et D så bl.a.
Z=4*p-(p+1-N)^2 kan skrives som DV2 for kvadratfrit D.
Desuden skal en række kongruensbetingelser opfyldes: p mod 8 tjekkes og værdien af
K=floor(sqrt(p)+1)2/r) beregnes.
Så kan der konstrueres en kurve med den komplekse diskriminant D (sqrt(-D)) der opfylder
betingelserne. Jo mindre D jo lettere at finde kurve. For små D findes en tabel for A og B –
startværdier
4
Et tal der enten et stort primtal p eller at faktorerne er et meget stort p og et meget lille q. 1,2 eller 3 fx
14
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
D
A
B
1
1
0
2
-30
56
3
0
1
7
-35
98
11
-264
1694
…
…
…
For større D er der en længere algoritme der kan følges
Eksempel 1:
Forsøgsvist sættes N=2*631 og legemets størrelse til p=1249, vi beregner da
Z=4*1249-(1249+1-1262)^2=4852. 4852 faktoriseres til 22*1213. Det giver et stort D , der
ganske vist opfylder kongruensbetingelserne, men er ikke så velegnet pga af D’s størrelse.
Eksempel 2:
N=3*1399=4197, p=4273, dvs Z=4*4273-(4274-4197)2=11163. Faktoriseret: 3*612
Det er svært at ramme en Z værdi der giver DV2 for passende værdier da de fleste tal har
mange små faktorer, men ovenstående er et heldigt eksempel
Vi tjekker p mod 8, 4273 mod 8=1 og værdien af K=floor(sqrt(p)+1)2/r)=
floor((sqrt(4273)+1)2/1399)=3
Og vi har* at If p = 1 (mod 8) og K = 2 or 3, så er mulige værdier af D = 1, 2, 3, 5, 6, 10, 11, 13,
14, 17, 19, 21,
Dvs D=3 og vi har E(F4273):Y2=X3+1 og dermed har vi at kurven måske har ordenen
#(Efp)=4197
Det ses straks at punktet (0,1) er en løsning og en gennemregning viser at punktet desværre
kun er genererer 6 punkter på kurven: (2,3)(0,1)(4272,0)(0,4272)(2,4270),O.
Vi skal derfor se på en faktor på B– jf 14.4.2 Derfor skal findes en faktor t*B.
Ex: t=88 og punktet P:(1673,322) er punktets orden 1399, for punktet P: (14,456) er ordene
4197, så E(F4273):Y2=X3+88 kan bruges.
Mange værdier af t giver fornuftig brugbar kurve, mange andre værdier giver dog ikke det
ønskede. Men det er muligt relativ let i dette eksempel at finde flere match, f. eks: t=1374
P:239,98 giver ordenen 4197
7. Angreb - Måder at finde n for nP= Q
Der findes forskellige måder at forsøge at løse ECDLP på for at ECC system. Nogle af
systemerne udnytter uhensigtsmæssigheder i domæneparametre, andre er
statistiske. De første kan man forsøge at gardere sig imod ved velvalgte kurver og
legemer, de andre kan man forsøge at gardere sig imod ved at arbejde på så store
15
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
legemer med tilstrækkeligt stort antal punkter på kurverne at det tager tid og
regnekraft udenfor det mulige. Herunder forsøgt meget kort at ridse ideen bag et
par af de centrale angrebsmåder op. Denne oversigt er på ingen måde udtømmende
og beskrivelserne er meget udetaljerede. Området er naturligvis genstand for meget
stor interesse og der udgives vedvarende artikler med forbedring af eksisterende
metoder og ind imellem helt nye metoder.
Weil pairring og MOV attack
Meget kort kan principperne bag Weil pairring og MOV attack beskrives således:
Der findes en størrelse em kaldes Weil-pairingen, der er en måde at beregne en
skalarværdi for to punkter P og Q i E(Fp) af orden m således at em(P,Q)m=1.
Denne størrelse kan også kaldes den m’te enhedsrod. Jeg vil ikke gå nærmere ind i
hvordan weil-pairingen beregnes, det kræver en lidt længere forklaring, men blot
eksemplificere. Detaljer kan fx findes hos Silverman[9] s.322.
Finder vi fx ud af at Weil-pairingen af to punkter P og Q på E(F631) er e5(P,Q)=242
betyder det at 2425=1 i F631
Har vi desuden at f.eks P’=3*P og Q’=4*Q og at vi har beregnet e5(P’,Q’)=512 findes
yderligere den egenskab at e5(P,Q)12 =24212= 512=e5(P’,Q’)=e5(3P,4Q)
Sådanne egenskaber kan vi bruge til at løse det ECDLP med via den såkaldte MOV
algoritme. Ideen er at transformere ECDLP i Fp til at løse DLP i F*pk.
MOV algoritmen – efter Menezes, Okamoto og Vanstone, ser ud som følger for to
punkter P og Q hvor Q=nP på E(Fp) for ukendt n. Lad P have primtalsorden j større
end sqrt(p)+1
1. Beregn antallet af punkter N på E(Fpk). Vi har at j deler N fordi E(Fp) har et
punkt af orden j.
2. vælg et tilfældigt punkt T der ligger i E(Fpk) men ikke i E(Fp)
3. beregn T’=(N/j)*T. Hvis T’= 𝒪𝒪 vælg et andet T. Ellers er T’ et punkt af ordenen
j.
4. beregn Weil-pairingen for følgende punkter
a=ej(P,T’) der vil ligge i F*pk . og tilsvarende for b = ej(Q,T’)
5. Find en løsning n til b=an (med andre ord løs DLP i F*pk .)
6. Vi har da at Q=nP
I tilfælde af supersingulære kurver eller anormale kurver giver algoritmen simple
løsninger, generelt kan DLP løses f.eks ved hjælp af index metoden. Jf [9]s.162 og se
evt. her 5
5
http://en.wikipedia.org/wiki/Index_calculus_algorithm
16
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Pollards Rho metode
Pollards Rho metode er normalt en metode til at faktorisere et tal n =pq for p og q to
store primtal. Men metoden er også relevant forhold til at finde n for Q=nP
Ideen bag Pollards Rho metode er mod n at finde to forskellige talpar (a1,b1) og
(a2,b2) så
a1*P + b1*Q = a2*P + b2*Q da vi så har at (a1-a2)*P =(b2-b1)*Q=(b2-b1)*t*P og
dermed at (a1-a2) =(b2-b1)*t mod n. t kan da beregnes som t= (a1-a2)* (b2-b1)-1 mod n
Metoden er så at konstruere en funktion der laver tilfældige kombinationer af talpar
indtil et match findes.
Et lille eksempel jf [5]. Hvis vi har E(F229): Y2=X3+x+44 og har P=(5,116) med
primtalorden 239 og Q=(155,166)) hvor Q= nP for ukendt n. Finder man så ved hjælp
af iterationer over tilfældige kombinationer f.eks at
192P+24Q=213P+104Q=(57,105), da har vi at t=(192-213)*(104-24)-1 mod 239=176.
Altså at 176*Q=P.
Metoden er statistisk da der ikke gives nogen garanti for match, men match kan
forventes at findes i tiden O(sqrt(N)), N gruppens orden.
Pohlig – Hellman metode
Denne metode virker hvis vi har at ordenen N af punktet P er et sammensat tal som
vi kan faktorisere.
Vi har en gruppe baseret på en elliptisk kurve E over Fp og punkterne P og Q hvor
Q=nP for et ukendt n.
Antag at faktoriseringen af N er følgende 𝑁𝑁 = 𝑞𝑞0 𝑒𝑒0 ∗ 𝑞𝑞1 𝑒𝑒1 ∗ 𝑞𝑞2 𝑒𝑒2 ∗ … .∗ 𝑞𝑞𝑖𝑖 𝑒𝑒 𝑖𝑖
Hvis vi da har at for et q med præcis den potens e der deler N kan vi skrive n som en
q-base ekspansion (var fx q=2 og e=1 ville det svare til en binær ekspansion)
Vi vil da forsøge med alle faktorerne i N ved at finde n modulus hvert 𝑞𝑞𝑖𝑖 𝑒𝑒 𝑖𝑖 og
efterfølgende bruge den kinesiske restsætning 6 til at finde n mod N.
Vi beregner for alle faktorpotenserne en mængde af punkter T som et skalarprodukt
af alle værdier af j mellem 0 og q-1 og N/q*P for at finde de forskellige værdier for n
Washington [2] viser et eksempel for E(F599) med punkter P=(60,19 og Q=(277,239)
hvor ordenen af P;N=600 der faktoriseres til 23*3*52. Ideen er så at beregne n mod
8, 3 og 25 og kombinere disse. Han får følgende kongruenser n= 2 mod 8,x=2 mod 3
og x=16 mod 25. Det giver til sammen n=266 mod 600 hvorfor n=266.
Denne metode kan man altså gardere sig imod ved at sikre at ordenen af punktet er
et primtal.
6
http://mathworld.wolfram.com/ChineseRemainderTheorem.html
17
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Pohlig-Hellmann angreb gennemregnet
Eksempel på kurve hvor punktets orden ikke er af primtals orden.
E(F5437):Y2=X3 – 3X + 4483, Base point example P: (10,4)
Orden af punkt P er N= 890
Man kan ved at regne på kurve eksempelvis se at 8P giver (1298,210) med orden
445. Et kvalificeret gæt på gruppens orden: 5340, da 6*890= 5340og 12*445=5340,
5437-5340=97 og tallet faktoriseres således 5340=22*3*5*89
Da punkternes orden skal gå op i gruppens orden og gruppens orden ifgl Hasse ikke
er meget forskellig fra antallet af elementer i legemet er det et rimeligt bud.
Vi vil da forsøge at udføre et Pohlig – Hellmann attack på ECDLP i denne gruppe
Vi har et Q=(3210,4634)=k*P for ukendt k
Punktet P=(10,4)’s orden N= er 890= 2*5*89
Vi har et Q=(3210,4634)=k*P for ukendt k, så vi skal i stedet forsøget at finde k for kP
mod 2, mod 5 og mod 89. Det er klart det er sværest at finde det mod 89 – og dette
problem skaleres op jo større primfaktorer gruppens orden er sammensat af.
Vi beregner elementerne T for hver faktorportens i N.
For k mod 2
Beregn T={j(N/q)*P for 0<=j<=q-1}, her er q så lig med 2
Dvs T={O,890/2*P}= {O,(4085,0)} , vi vil så finde N/q*Q =445*( 3210,4634)=O dvs:
Vi har altså 0*(N/2*P) og dermed at k0=0
Dvs Q1=Q-0P=Q. Dvs k=0 mod 2 (med andre ord et lige tal)
For k mod 5
Beregn T={j(N/q)*P for 0<=j<=q-1}, her er q så lig med 5 og N/q=178 så vi har
T={O,178P,356 P,534P,712P}=
T={O, (3474,2391),(2641,4651),( 2641,786),(3474,3046)}
N/5*Q=178*Q=(2641,4651) og vi ser at det er det samme som det tredieelement i T
listen ovenfor og at det svarer til
N/5*Q= 2*N/5*P altså k0=2, Det vil sige k=2 mod 5
For k mod 89
18
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Beregn T={j(N/q)*P for 0<=j<=q-1}, her er q så lig med 89 og N/q=890/89=10 så vi har
T={O,10P,20P,30P,40P,50P,60P,70P,……39*10P,40*10P,41*10P,42*10P,…..,87*10P,8
8*10P }= T={O, (3820,4000),( 5098,1859),( 3664, 2503),……(819,5180)…….}
N/89*Q=10*Q=(819,5180) . Det kan vi ved mange lange beregninger se er det
samme som det element i T listen hvor j=42,altså 420*P ovenfor og det svarer til
N/89*Q= 42*N/89*P altså k0=42, Det vil sige k=42 mod 89
Vi har derfor følgende kongruenser:k=0 mod 2, k=2 mod 5, og k=42 mod 89. Det løses
med kinesisk restsætning til k=42.
Som eksemplet viser giver større primtalsfaktorer længere beregninger, og det er da
også grunden til at angrebet er velegnet især for punkter sammensat af små
primtalspotenser.
For et beskytte sig mod Pohlig-Hellman angrebet skal kan man også vælge punkter af
sammensat orden hvor ordenen er sammensat af en stort primtal og men meget lille
co faktor.
8. Suite B
Suite B 7er en amerikansk standard udgivet af National Security Agency(NSA) for
sikker kommunikation på niveauet SECRET (svarende til dansk klassifikation
HEMMELIGT) . Standarden er godkendt af NIST der er den amerikanske
standardiseringsinstitut – National Institute of Standards and Technology.
Der findes også en Suite A. Den er beregnet til særlig beskyttelse af sensitiv
information (TOP SECRET) og indeholder fortrolige algoritmer. Denne standard vil
ikke blive offentliggjort.
Suite B indeholder en lang række dokumenter vedr. standarder for protokoller og
algoritmer herunder bl.a. andet følgende dokumenter vedr. kryptografi med
Elliptiske kurver. De refererer desuden til de af NIST anbefalede elliptiske kurver til
kryptografisk brug.
FIPS-186-3
Elliptic Curve Digital Signature Algorithm (ECDSA) – FIPS PUB 186-3 (using the curves
with 256 and 384-bit prime moduli)
Implementationsguide til FIPS-186-3
Suite B Implementers' Guide to FIPS 186-3 (ECDSA) - February 2010
Matematiske rutiner til NIST kurver
Companion document Mathematical Routines for NIST Prime Elliptic Curves
7
http://www.nsa.gov/ia/programs/suiteb_cryptography/
19
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
NIST anbefalinger, standard
IEEE P1363-Annex A (kommercielt produkt – 149$) 8
Suite B indeholder bl.a. anbefaling eller krav om man vil, til hvilke
domæneparametre herunder hvilke kurver anvendes til kryptografisk brug i FIPS186-3 appendix D.
Jeg vil i denne gennemgang ikke se nærmere på protokolkrav på Suite B niveau og vil
primært undersøge og anvende de anbefalede såkaldte NIST kurver til
demonstrationsbrug. Implementationsguide og de optimerede matematiske rutiner
er tilføjet for nylig og er generelt ikke anvendt her, men visse steder kommenteret i
forbindelse med implementationsovervejelser.
NIST anbefalinger
Legemer
NIST anbefaler følgende endelige legemer. 5 primlegemer og 5 binære legemer.
Primlegemer for Fp for følgende værdier af p:
𝑝𝑝 = 2192 − 264 − 1 =
6277101735386680763835789423207666416083908700390324961279
𝑝𝑝 = 2224 − 296 + 1 =
26959946667150639794667015087019630673557916260026308143510066298881
𝑝𝑝 = 2256 − 2224 + 2 192 + 296 − 1 =
115792089210356248762697446949407573530086143415290314195533631308867097853951
𝑝𝑝 = 2384 − 2128 − 2 96 + 232 − 1 =
394020061963944792122790401001436138050797392704654466679482934042457217714968703290472660
88258938001861606973112319
𝑝𝑝 = 2521 − 1 =
686479766013060971498190079908139321726943530014330540939446345918554318339765605212255964
0661454554977296311391480858037121987999716643812574028291115057151
Disse primmoduli er angivet på en speciel form kaldet generaliseret Mersenne form.
Beregninger på modulus på denne form giver beregningsmæssige fordele. Et optimeret
kryptosystem vil med stor fordel kunne implementere artimetik der udnytter disse frem for
8
https://sbwsweb.ieee.org/ecustomercme_enu/start.swe?SWECmd=GotoView&SWEView=Catalog+Vi
ew+(eSales)_Standards_IEEE&mem_type=Customer&SWEHo=sbwsweb.ieee.org&SWETS=1192713
65
20
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
standard implementation der ville virke på ethvert primtal.
Detaljer omkring denne optimering vil fremgå af guiden 9hørende til Suite B, samt af FIPS186-3. Ideen er overordnet set at en binær baseret ekspansion giver særlige fordele hvor
beregninger kan foretages i forenklet binære operationer. Fx er modulus for kurven P-192
skrevet som
p = 2 192 – 2 64 – 1. Det betyder at ethvert tal mindre end p2 kan skrives på formen
A=A5*2320 + A4*2256+A3*2192+A2*2128+A1*264+A0
Her vil hvert Ai så være et 64 bit tal, og det kan da betragtes som en konkatenering
af 64-bit ord således A=(A5||A4||A3||A2||A1||A0)). Modulus beregninger vil da
kunne beregnes som en sum af små tal reduceret modulus p
Vil vi f.eks beregne B = A mod p har vi at B= T + S1 + S2 + S3 mod p hvor
T=(A2||A1||A0), S1=(A3||A3), S2=(A4||A4||0), S3 =(A5||A5||A5). Tilsvarende teknik
virker på de andre primlegemer.
Optimering på NIST Kurver – numerisk eksempel
Matematiske rutiner på p192
Beregn r= a mod p192
r kan da beregnes som t + s1 + s2+s3 og ved efterfølgende subtraktion af op til tre multiplum af p192
Så lad os tage et eksempel hvor a er repræsenteret ved 64 bit enheder med værdien 2305
(altså a6,a5,a4,a3,a2,a1,a0)=(0,0,0,2,3,0,5)
Vi har da at T er (a2 ||a1||a0) = 305
Og S1=(a3||a3), s2=(a4||a4||0), S3 =(a5||a5||a5). Dvs: T=305, S1=22, S2=000, S3=000
T + S1+S2+S3= 327 der beregnes til at være:
Så r= t + s1 + s2+s3 = 327= 3*2^(2*64)+ 2*2^(1*64) +7*2^(0*64) =
1020847100762815390427017310442723737607
Hvis vi i stedet beregner det ’normalt’:
a= 2305 angives som 64 bit giver:
2*2^(3*64)+ 3*2^(2*64)+ 0*2^(1*64) +5*2^(0*64)=
12554203470773361528692425947178148222594834711223373660165
192
64
Hvis vi modulerer det med 𝑝𝑝=2 −2 −1 =
6277101735386680763835789423207666416083908700390324961279
Får vi > 12554203470773361528692425947178148222594834711223373660165 mod
6277101735386680763835789423207666416083908700390324961279;
Hvilket i Maple præcist giver 1020847100762815390427017310442723737607.
9
Companion document Mathematical Routines for NIST Prime Elliptic Curves
21
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Det ses altså at være langt enklere at regne via de optimerede rutiner.
Binære legemer
F2163= F11692013098647223345629478661730264157247460343808
F2233= F13803492693581127574869511724554050904902217944340773110325048447598592
F2283= F15541351137805832567355695254588151253139254712417116170014499277911234281641667985408
F2409=
F1322111937580497197903830616065542079656809365928562438569297590548811582472622691650378420879430569
695182424050046716608512
F2571=
F7729075046034516689390703781863974688597854659412869997314470502903038284579120849072387533163845155
924927232063004354354730157322085975311485817346934161497393961629646848
Man vil her bemærke at det netop er disse legemer jeg beregnede antallet af punkter for i
afsnittet under Elliptiske kurver over binære legemer.
NIST kurver
På disse legemer specificeres så kurver med tilfældigt valgte parameter der opfylder en
række krav.
På primlegemerne specificeres en kurve på hvert legeme. På de binære legemer specificeres
både en tilfældig valgt kurve og en Koblitz kurve pr legeme.
Kurvespecifikation kaldes også domæneparametre . Følgende værdier afgives for at
muliggøre kryptografisk brug. Først for kurver over primlegemer; værdien af henholdes vis A
og B for den elliptiske kurve på den korte Weierstrass form: Y2=X3 + AX + B, samt
koordinaterne for et basepunkt G - Gx og Gy.
Desuden oplyses forskellige andre værdier til kontrol af kurvens egnethed, herunder antallet
af punkter på kurven (kurvens orden) og to sammenhængende kontrolværdier, et seed S og
et output c til verifikation af at kurven faktisk opfylder kravet om at være tilfældig.
For kurver over binære legemer gives et reduktionspolynomium af grad m, koefficienterne A
og B for en kurve på formen: y2 + XY = X3+AX2+B, koordinaterne for at basepunkt G, Gx og Gy
samt punktets orden. Dvs det t for hvilket tG=𝒪𝒪
Valg af reduktionspolynomium.
Ved anvendelse af polynomialbasis repræsentation for 𝐹𝐹2𝑚𝑚 giver det en række muligheder
for valg af reduktionspolynomium.
Det forholder sig dog sådan at der findes en række meget konkrete anbefalinger for valg af
disse.
Ifølge IEEE 1363-2000 , FIPS-186-2 og ANSI X9.62 vælges så enkle reduktionspolynomier
som muligt efter følgende princip:
Hvis der findes et ireducibelt trinomium af grad m over F2, 𝑋𝑋 𝑚𝑚 + 𝑋𝑋 𝑘𝑘 + 1 , vælges dette, og
da med så lille en værdi af k som muligt. Hvis dette ikke findes vælges der i stedet et
pentanomium.
𝑋𝑋 𝑚𝑚 + 𝑋𝑋𝑘𝑘 3 + +𝑋𝑋𝑘𝑘 2 + 𝑋𝑋𝑘𝑘 1 + 1 med følgende kriterier for valg af k værdier. k3 vælges så lille
som muligt og for dette valg så lille et k2 som muligt, og for disse værdier af k3 og k2 vælges
så lille et k1 som muligt.
22
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Dette betyder for ovennævnte binære legemer ifølge Doche[1] 10, følgende valg af
reduktionspolynomier:
F2163  𝑋𝑋163 + 𝑋𝑋 7 + +𝑋𝑋 6 + 𝑋𝑋 3 + 1
F2233  𝑋𝑋 233 + 𝑋𝑋 74 + 1
F2283  𝑋𝑋 283 + 𝑋𝑋12 + +𝑋𝑋 7 + 𝑋𝑋 5 + 1
F2409  𝑋𝑋 409 + 𝑋𝑋 87 + 1
F2571  𝑋𝑋 571 + 𝑋𝑋10 + +𝑋𝑋 5 + 𝑋𝑋 2 + 1
9. Generering og verifikation af domæne parametre
Et af de centrale aspekter ved sikkerheden bag brug af EC til kryptografi er sikring af
at kurverne som nævnt er valgt tilfældigt således at en udbyder af en
krypteringsservice ikke kan vælge sig parametre der muliggør forskellige kendte
angreb.
Ifølge NIST og algoritmen 4.17 [5] genereres A og B på baggrund af et valgt Fp ved
hjælp af en hash funktion således at outputtet ikke kan være forhåndsvalgt ud fra en
antagelse om at hash funktionen er en envejsfunktion med uforudsigeligt og
entydigt resultat. Her er algoritmen beskrevet med SHA1 som det skal være ifølge
fips-186-3
Input: primtal p og en 160 bit hashfunktion H
Output: et seed S og A og B for den elliptiske kurve E på kort Weierstrass
form.
1. sæt t=loft(log2p), s = floor(t-1)/160, v= t-s*160
2. Vælg tilfældig bitstreng S af længde g>= 160 bit
3. beregn h=sha1(S), og lad r0 være bitstrengen af længde v bit ved at tage
de v bit længst til højre af h
4. lad R0 være bitstrengen der er resultatet ved at sætte den bit længst til
venstre til 0.
5. lad z være det tal hvis binære repræsentation er S
6. for i=1;i<=s;i++
1. lad si være g bit streng-repræsentationen af tallet (z+i) mod 2g
2. Beregn Ri = H(si)
7. Lad R være strengkonkateneringen af Ri værdierne :
R=R0||R1||R2||….||Rs
8. lad r være det tal hvis binære repræsentation er R
9. hvis r=0 eller hvis 4r + 27 = 0 mod p tilbage til 2. o g vælg ny bitstreng
10. Vælg tilfældig A og B i Fp forskellig fra 0 så r*B2=A3
11. returner S,A og B.
10
Tabel s 216, kap 11.2 Finite fields of characteristic 2. Handbook of Elliptic and Hyperelliptic Curve Cryptography
23
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
De af NIST anbefalede kurver er alle genereret ved hjælp af SHA-1
Man kunne godt stille spørgsmål ved kvaliteten af dette valg, idet SHA-1 er
kompromitteret. For at en hashfunktion kan betegnes som værdifuld skal
entydigheden være sikker. Da ingen hashfunktioner af endelig længde pr
konstruktion kan være kollisionsfri skal i praksis være så kollisionsfrie som muligt, og
endnu vigtigere, det må ikke være muligt at forudsige resultatet af funktionen, så
der f.eks. kan konstrueres en kollision
På Crypto-2004 viste Xiaoyun Wang, Yiqun Lisa Yin, and Hongbo Yu at det er muligt
at generere kollisioner væsentlig hurtigere end hidtil antaget med SHA-1. Ifølge
Bruce Schneier 11 reduceres til 2^69 operationer frem for 2^80
I den seneste version af standarden, fips-180-3 fra juni 2009, er de anbefalede
kurver fortsat genereret med et specificeret 160 bit seed og SHA-1 anvendt til at
dokumentere at parametrene er valgt pseudo-randomiseret.
Det er altså en teoretisk mulighed at de af NIST anbefalede kurver til Suite B
standarden er konstrueret så nogen har sikret sig parametre med for dem kendte
genveje til angreb.
Man kunne også stille spørgsmål ved sikkerheden i at anvende domæneparametre
der er offentliggjorte og forlangt anvendt af kun den ene part i en kommunikation
hvor den eneste sikkerhed for tilfældighed er en brudt hash algoritme.
Omvendt har de anbefalede kurver nu i en årrække været offentligt tilgængelige og
er blevet nøje gransket af utallige personer og eventuelt indbyggede svagheder
måtte forventes at være fundet.
Ønsker man at konstruere sine egne domæneparametre undgår man naturligvis at
andre har indbygget et eller flere, af dem kendte, svagheder, omvendt vil da restere
et arbejde med sikring af at kurverne lever op til kendte krav og kan modstå kendte
angreb.
Desuden vil den klassiske problemstilling altid lure i baggrunden – at når man
anvender hjemmekonstruerede parametre ikke er gennemprøvede på samme måde
som kendte standarder, er der altid risiko for at overse oplagte problemer, ikke blot i
konstruktionen, valg og test men naturligvis også i implementation.
Verifikation
NIST kurve eksempel over primlegeme, kaldet P-192
E(Fp)
A=-3
11
http://www.schneier.com/blog/archives/2005/02/sha1_broken.html
24
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
B er angivet som:
B= 2455155546008943817740293915197451784769108058161191238065
p = 2^192-2^64-1
=6277101735386680763835789423207666416083908700390324961279
Base punkt G er I fips-186-2 og 3 angivet I hex til :
Gx:188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012
Gy:07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811
Det giver i decimal form:
Gx: 602046282375688656758213480587526111916698976636884684818
Gy: 174050332293622031404857552280219410364023488927386650641
Det kan først efterprøves og bekræftes at punktet faktisk G ligger på kurven idet B kan
verificeres at være lig med B=Gy^2 -Gx^3 – (-A)*Gx mod p=
(174050332293622031404857552280219410364023488927386650641)^2-
(602046282375688656758213480587526111916698976636884684818)^3-(-3)*(
602046282375688656758213480587526111916698976636884684818) mod
6277101735386680763835789423207666416083908700390324961279 =
2455155546008943817740293915197451784769108058161191238065
At kurven virkelig er pseudo-random skulle så kunne verificeres ved hjælp af det
angivne seed S til en hashbaseret algoritme og sammenligne det med det angivne
output c af denne.
c tjener yderligere til at bekræfte at domæneparameteren, koefficienten B, opfylder
kravet B2*c=-27(mod p )
Jeg vil derfor her ved hjælp af algoritmen angivet i appendix 6.5 fips-180-3, også
specificeret i [5] s 176 forsøge at verificere at c og B er korrekte via 160 bit
hashalgoritmen SHA-1.
Verifikation af pseudo-randomisering
Givet 160-bit seedet s, kan man verificere at koefficienterne A og B er beregnet fra
den hashfunktionen SHA1 som følger
Lad l være bitlængden af p, og definer
v = ( l - 1) /160 (floor)
w = l - 160v - 1
1. Beregn h := SHA-1(s).
2. Lad h0 være bitstrengen fremkommet ved at tage de w bil længst til højre af h
3. Lad z være heltallet hvis binære ekspansion er givet ved 160 bit strengen s
4. For i fra 1 til v do
4.1 Definer 160-bit strengen si to til at være den binære ekspanstion af
(z + i) mod (2160 ).
4.2 Beregn hi :=SHA-1(si).
25
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
5. Lad h være bitstrengen fremkommet ved strengkonkatenering af h0 , h1, . . . , hv
som følger:
h = h0 || h1 || . . . || hv.
6. Lad c være det heltal hvis binære ekspansion er givet ved bitstrengen h
7. Verificer at b2*c= -27 (mod p).
Sha1 hashing af hexværdier
Det viser sig til at det ikke er helt lige meget hvordan man tager hashværdien af de angivne
hexværdier. Det er ikke specificeret hvordan hexværdien skal fortolkes og hvordan
encodingen foregår. SHA1 er ganske vist standardiseret i Fips men mange forskellige
implementationer er mulige og afhængig af valg af programmeringssprog. Det er fx
afgørende at seedet ikke fortolkes som en tekststreng. Det kan dog heller ikke blot
oversættes til et stort heltal.
Efter en række forsøg er det lykkes at finde en fortolkning der giver det rigtige resultat – ved
at parse hexværdierne til et bytearray der så hashes blok for blok. Herunder et eksempel.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
using System.Security.Cryptography;
namespace hashhex
{
class Program
{
public static byte[] FromHex(string s)
{
byte[] ba = new byte[s.Length / 2];
for (int i = 0; i < ba.Length; i++)
{
ba[i] = byte.Parse(s.Substring(2 * i, 2), NumberStyles.HexNumber);
}
return ba;
}
public static string HexSHA1(String s)
{
HashAlgorithm alg = new SHA1Managed();
byte[] b = FromHex(s.Replace(" ", ""));
alg.TransformFinalBlock(b, 0, b.Length);
return BitConverter.ToString(alg.Hash).Replace("-", "");
}
public static void Main(string[] args)
{
Console.WriteLine(HexSHA1("bd713447 99d5c7fc dc45b59f a3b9ab8f
6a948bc5"));
Console.WriteLine(HexSHA1("bd713447 99d5c7fc dc45b59f a3b9ab8f
6a948bc6"));
Console.ReadKey();
}
}
}
Denne implementation herover virker, mens mit første forsøg - en implementation som vist
i uddrag herunder, ikke virker . Den i hex angivne værdi s oversættes til et stort helttal,
dette tal parses til et bytearray og sha1 værdien at disse printes ud i binært format.
26
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
private void button1_Click(object sender, EventArgs e)
{
BigInteger num = BigInteger.Parse(textBox1.Text);
byte[] data = num.ToByteArray();
byte[] result;
StringBuilder sb = new StringBuilder();
SHA1 sha = new SHA1CryptoServiceProvider();
result = sha.ComputeHash(data);
for (int i = result.Length - 1; i >= 0; i--)
{
sb.Append(Convert.ToString(result[i], 2).PadLeft(8, '0'));
}
}
textBox2.Text = sb.ToString().TrimStart('0');
At man skal være overordentlig varsom med hvilken implementation af sha1 der anvendes,
kan også vises i et lille kuriosum herunder:
PHP’s implementation af sha1 giver ingen fejlmeddelelser, men dog resultater, hvis man
tager sha1 værdien af store tal. I stedet for som dokumentationen anfører hashværdi af
tekststrenge – og det bliver her meget tydeligt at funktionen ikke kan anvendes til
kryptografisk brug. Kun de første 14 digitale cifre har betydning for hashværdien - Her ses et
forsøg på at beregne hashværdien af S sammenlignet med S+1 og anden værdi der er
sammenlignelig i decimal form.
<?php echo sha1(275585503993527016686210752207080241786546919125);?> </br>
<?php echo sha1(275585503993527016686210752207080241786546919126);?> </br>
<?php echo sha1(275585503993527000000000000000000000000000000000);?> </br>
831f335f6b0dbd2e21167573824933a2e9038e15
831f335f6b0dbd2e21167573824933a2e9038e15
831f335f6b0dbd2e21167573824933a2e9038e15
Heller ikke sha1 værdien af de angivne seeds fortolket som tekststrenge giver noget brugbart med
PHP.
Undervejs i disse beregninger har jeg undersøgt mange forskellige implementationer af sha1
hvoraf de færreste har givet det resultat der skulle til for at bekræfte ovenstående.
Det vil derfor være nødvendigt at sikre sig en sha1 implementation der kan håndtere
hexværdier og i øvrigt er implementeret henhold til suite B for at være sikker på at den er
korrekt implementeret.
Ifølge Certicom http://www.certicom.com/index.php/net lever sikkerheds API’et inkluderet i
.NET ikke op til FIPS standard. Man vil i stedet kunne anskaffe sig et særligt ”Certicom API,
security.NET with fips”. Det kunne eventuelt give den nødvendige sikkerhed for korrekt
hashvalidering.
Verifikation af P-192
S : 3045ae6f c8422f64 ed579528 d38120ea e12196d5
27
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
output c er på forhånd angivet som:
c:3099d2bb bfcb2538 542dcd5f b078b6ef 5f3d6fe2 c745de65
p er 6277101735386680763835789423207666416083908700390324961279
Bitlængden l af p er by design 192. Den kan også beregnes som l= Log2( p) = 192
Dvs v= (192-1)/160 =1
W= l-160*v – 1= 192-160-1= 31
S er angivet i hex og det ses at der er 5 blokke a 8x4 bit altså 160 bit. S er her udtrykt
i binær form:
S: 3045ae6f c8422f64 ed579528 d38120ea e12196d5
sha1(s)=7f6da10026c7ff92c5ac2e890bd59b44b099d2bb
01111111 01101101 10100001 00000000 00100110 11000111 11111111
10010010 11000101 10101100 00101110 10001001 00001011 11010101
10011011 01000100 10110000 10011001 11010010 10111011
R0 er de 31 bit længst til højre
for i = 1 til v (men v = 1 så for i =1):
si= z + i dvs s1=z+1 mod 2^160
s1=275585503993527016686210752207080241786546919125+1 mod 2^160
Idet 2^160 = 1461501637330902918203684832716283019655932542976 er
meget større end s får moduleringen ingen indflydelse på beregningen
s1 =3045ae6f c8422f64 ed579528 d38120ea e12196d6 =
sha1(s1)=bfcb2538542dcd5fb078b6ef5f3d6fe2c745de65
R1 = SHA1(s1)=
10111111 11001011 00100101 00111000 01010100 00101101 11001101
01011111 10110000 01111000 10110110 11101111 01011111 00111101
01101111 11100010 11000111 01000101 11011110 01100101
Og da r = R0 || R1 (hvor || skal forstås som strengkonkatenering)
C omsat til binært tal er:
00110000
00111000
10110110
01000101
10011001
01010100
11101111
11011110
11010010 10111011 10111111 11001011 00100101
00101101 11001101 01011111 10110000 01111000
01011111 00111101 01101111 11100010 11000111
01100101
Den første markerede del af tallet er de 31 mindst betydende cifre :R0, direkte fra
beregningen sha1(S)
28
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Ydermere skulle kunne verificeres på om r*b2=a3 mod p, og er det ikke det, kan
randomisering afvises.
Da r kunne verificeres at være identisk med c er tilbage blot at tjekke at
c*b2= a3 mod p
c på decimal form:
1191689908718309326471930603292001425137626342642504031845
Vi har at den elliptiske kurve er angivet med følgende værdier for a og b:
a=-3
b= 2455155546008943817740293915197451784769108058161191238065
Og får derfor følgende regnestykke
Først via vores beregnede r og efterfølgende for det i standarden angivne r
r*b2=
1191689908718309326471930603292001425137626342642504031845*
24551555460089438177402939151974517847691080581611912380652 mod
6277101735386680763835789423207666416083908700390324961279=
6277101735386680763835789423207666416083908700390324961252
a3=(-3)3 mod
6277101735386680763835789423207666416083908700390324961279=
6277101735386680763835789423207666416083908700390324961252
Hvilket tydeligvist er det samme.
Verifikationen af randomiseringen var således bundet op på en korrekt implementation af
SHA1.
Yderligere verifikationsovervejelser:
Det er naturligvis afgørende at r er fremkommet ved hjælp af en hash funktion og
kan bekræftes via det angivne seed, da en accepttest der alene baserer sig på at
verificere at det allerede angivne r bekræfter af r*b2 = a3 mod p er værdiløs da man
nemt kan konstruere et sådant r
r skal da blot angives til at være r = a3 /b2 mod p, hvilket let beregnes.
Eksempel - At konstruere r for P-224
𝑝𝑝 = 2224 − 296 + 1 dvs.
p=26959946667150639794667015087019630673557916260026308143510066298881
b=b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943
2355ffb4 som i decimalform er:
18958286285566608000408668544493926415504680968679321075787234672564.
29
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Først beregnes a3 mod p= (-3)3 mod
26959946667150639794667015087019630673557916260026308143510066298881=
26959946667150639794667015087019630673557916260026308143510066298854
b2 mod p =
418022388386432022296331202075632536960789719528665395361463976209 =
9585649763196999776159690989286240671136085803543320687376622326267
i specifikationen er r da også angivet til at være: r= 5b056c7e 11dd68f4 0469ee7f 3c7a7d74
f7d12111 6506d031
218291fb i decimalform:
9585649763196999776159690989286240671136085803543320687376622326267
Hvilket ses at være det samme som det beregnede.
Så med mindre det kan bekræftes at S r vha [11]side 64 og [5]side 176 er r værdien ikke
validerende.
Hele sikkerheden i valideringen er altså baseret på at det ikke er muligt at skabe et S så r
S, og dette hænger naturligvis på hashfunktionen.
Test af domæneparametre for P-224:
S= bd713447 99d5c7fc dc45b59f a3b9ab8f 6a948bc5
sha1(s)= 2f7923f33d5eab4215c2fc265b056c7e11dd68f4
binært 
00101111 01111001 00100011 11110011 00111101 01011110 10101011
01000010 00010101 11000010 11111100 00100110 01011011 00000101
01101100 01111110 00010001 11011101 01101000 11110100
224-1/160=1, v = 224-1*160= 64 bits
Så R0 er de 64 bagerste bits:
01011011 00000101 01101100 01111110 00010001 11011101 01101000 11110100
c’s værdi I hex: R0 + R1
01011011
00000100
11110111
00100001
00000101
01101001
11010001
10000010
01101100
11101110
00100001
10010001
01111110 00010001 11011101 01101000 11110100
01111111 00111100 01111010 01111101 01110100
00010001 01100101 00000110 11010000 00110001
11111011
Det ses at det matcher!
R1
30
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
S1= bd713447 99d5c7fc dc45b59f a3b9ab8f 6a948bc5+1= bd713447 99d5c7fc dc45b59f
a3b9ab8f 6a948bc6
Sha1(s1)= 0469ee7f3c7a7d74f7d121116506d031218291fb
I binært format:
00000100 01101001 11101110 01111111 00111100 01111010 01111101 01110100
11110111 11010001 00100001 00010001 01100101 00000110 11010000 00110001
00100001 10000010 10010001 11111011
Altså kan domæne parameter verificeres for P-224
Test af domæne parametre for P-521
S: d09e8800 291cb853 96cc6717 393284aa a0da64ba
Sha1(s)= 191089dcebc9e37dfc2e3c3f0058e2b48bfa5f42  binært
00011001 00010000 10001001 11011100 11101011 11001001 11100011 01111101
11111100 00101110 00111100 00111111 00000000 01011000 11100010 10110100
10001011 11111010 01011111 01000010
521-1/160=3, v = 521-3*160= 41 bits
C’s værdi I hex:
0b4 8bfa5f42 0a349495 39d2bdfc 264eeeeb 077688e4
4fbf0ad8 f6d0edb3 7bd6b533 28100051 8e19f1b9 ffbe0fe9
ed8a3c22 00b8f875 e523868c 70c1e5bf 55bad637
giver binært det herunder med sort markerede:
01011 01001000 10111111 10100101 11110100 0010 = R0
00001011 01001000 10111111 10100101 11110100 00100000 10100011 01001001
01001001 01010011 10011101 00101011 11011111 11000010 01100100 11101110
11101110 10110000 01110111 01101000 10001110 01000100 11111011 11110000
10101101 10001111 01101101 00001110 11011011 00110111 10111101 01101011
01010011 00110010 10000001 00000000 00000101 00011000 11100001 10011111
00011011 10011111 11111011 11100000 11111110 10011110 11011000 10100011
11000010 00100000 00001011 10001111 10000111 01011110 01010010 00111000
01101000 11000111 00001100 00011110 01011011 11110101 01011011 10101101
01100011 00000111 = c
Som det ses så matcher R0.
Sha1(s1)= 0a34949539d2bdfc264eeeeb077688e44fbf0ad8
Binært 
00001010 00110100 10010100 10010101 00111001 11010010 10111101 11111100
00100110 01001110 11101110 11101011 00000111 01110110 10001000 11100100
01001111 10111111 00001010 11011000
Sha1(s2) = f6d0edb37bd6b533281000518e19f1b9ffbe0fe9 og binært:
31
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
11110110 11010000 11101101 10110011 01111011 11010110 10110101 00110011
00101000 00010000 00000000 01010001 10001110 00011001 11110001 10111001
11111111 10111110 00001111 11101001
Sha1(s3)= ed8a3c2200b8f875e523868c70c1e5bf55bad637 og binært
11101101 10001010 00111100 00100010 00000000 10111000 11111000 01110101
11100101 00100011 10000110 10001100 01110000 11000001 11100101 10111111
01010101 10111010 11010110 00110111
Som det ses er det nødvendigt at foranstille 4 nullere på se sidste 4 bit for at få matchet
korrekt.
10.
Implementationsovervejelser:
Store tal - BigIntegers
Da der til sikre løsninger, af såvel nøgleudveksling med EC, kryptering med EC og
andre kryptografisk relevante anvendelser, arbejdes med meget store tal hvor
punktets orden skal være større end 2^160 (jf. s 172 i [5])er det nødvendigt at kunne
håndtere heltal i den størrelsesordnen.
2^160 = 1461501637330902918203684832716283019655932542976
NIST anbefaler brug af kurver hvor domæneparameteren Fp har p værdier helt op til
2^521-1. Her i decimal form for at få et indtryk at størrelsesordnen:
68647976601306097149819007990813932172694353001433054093944634591
85543183397656052122559640661454554977296311391480858037121987999
716643812574028291115057151
Standard datatyper som fx float og double kan ikke rumme tal af denne størrelse og
især ikke med den præcision. En Uint64’s maximale værdi er fx:
18446744073709551615 og der er derfor behov for særlige forholdsregler.
Rosing [3]konstruerer i sine eksempler i C selv en ny datatype BIGINT baseret på
computerens ’int’ størrelse i bytes, der er forskelligt om computeren kører 64 bit
eller 32 bit. Han implementerer herunder også alle tilhørende nødvendige
matematiske rutiner; addition, multiplikation og division med henblik på optimering.
Java kommer i standard pakken med et BigInteger objekt og tilhørende
regneoperationer. Java er derfor naturligt nok ofte foretrukket til implementation af
EC kryptografi
Som noget nyt understøtter Miscrosoft.NET nu med frigivelsen af version 4.0 Big
Integers og i øvrigt også Complex numbers med bibliotektet System.Numerics.
For bedre performance er det helt grundlæggende afgørende at BigInteger
implementeres så disse matematiske standardrutiner er optimerede.
32
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Der findes desuden et kommercielt produkt - ’Extreme Optimization Numerical
Libraries for .NET’ der indeholder metoder der bl.a. er optimeret til meget store og
komplekse beregninger. http://www.extremeoptimization.com/
Jeg har i mine eksempler primært valgt at anvende Miscrosoft.NET’s BigInterger men
visse steder også anvendt indbyggede Extreme.Numerics samt matematik
programmet Maple til mindre eksempler.
Modulær multiplikativ invers
Euklid
Vælger vi at arbejde på et primlegeme vil vi i en lang række tilfælde være nødt til at
beregne det inverse element til et tal a, eller populært sat dividere med a i et
modulært univers. Elementet a har en invers hvis og kun hvis a* x = 1 mod p.
På et primlegeme er dette netop tilfældet.
At beregne a-1 mod p i realiteten betyder at finde løsningen til a* x = 1 mod p, og det
kan være omkostningsfyldte operationer, da der skal mange mellemregninger til for
at finde løsningen.
Men da p er et primtal og a har en værdi mellem 1 og p-1 har vi at gcd(a,p )= 1 kan vi
finde a-1 mod p ved hjælp af Euklids algoritme hvor a*x + p*y = 1
Men foretager en gentagen division af divisor med rest indtil resten er 0.
Et eksempel på Euklid inversionsalgoritme her:
Input: primtal p og et a hvor (1<=a<p-1)
Output: a^-1 mod p
12. u=a,v=p
13. x1=1,x2=0
14. while(u!=0)
1. q = v/u, r=v-qu, x=x2-qx1
2. v=u,u=r,x2=x1,x1=x
15. return x1 mod p
tegnet = skal betragtes som en tildelingsoperator og læses fra højre mod venstre
Et lille gennemregnet eksempel kan f.eks. ses her. 12
12
http://www-math.cudenver.edu/~wcherowi/courses/m5410/exeucalg.html
33
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Divisionsoperationer er beregningsmæssigt krævende og algoritmen kan derfor
optimeres ved at erstatte disse divisioner med binære højreshift (>>, et tal divideres
med 2 ved at shifte tallet en gang mod højre, 1010110 >> 1 giver således 101011 og
1011 >> 1 = 101 – svarende til heltalsdivision eller Math.floor efter division)
Et eksempel på en sådan binær algoritme for inversion i Fp her vist i uddrag i C# fra
det vedlagte implementationseksempel
private BigInteger ModularBinaryInverse(BigInteger a, BigInteger modp)
{
BigInteger u = a; BigInteger v = modp;
BigInteger r1 = 1; BigInteger r2 = 0;
while (u != 1 && v != 1) {
while (u.IsEven) {
u = u >> 1;
if (r1.IsEven) { r1 = r1 >> 1; } else { r1 = (r1 + modp) >> 1; }
}
while (v.IsEven) {
v = v >> 1;
if (r2.IsEven) { r2 = r2 >> 1; } else { r2 = (r2 + modp) >> 1; }
}
if (u >= v) { u = u - v; r1 = r1 - r2; } else { v = v - u; r2 = r2 - r1; }
}
if (u == 1) { return r1 % modp; } else return r2 % modp;
}
Populært sagt handler det i forhold til performance om antallet af runder i manegen
og kompleksiteten af de beregninger der udføres undervejs.
Fermat
Et alternativ til Euclids algoritme er at anvende Fermats lille sætning hvilket lyder
ap-1 = 1 mod p og en variant heraf a-1=ap-2 mod p
Med allerede optimerede regnefunktioner tilstede på bigIntegers i System.Numerics
til potensopløftning er det ganske let at beregne dette tal:
private BigInteger EasyInverse(BigInteger a, BigInteger modp) {
BigInteger result =BigInteger.ModPow(a, modp - 2, modp);
return result;
}
En optimeret implementation af operationer på elliptiske kurver vil typisk undgå
modulære inverser i størst muligt omfang. Da det er mere omkostningsfyldt end
addition og multiplikation.
Kvadratrødder modulus p implementation
Man kan fx beregne modulære kvadratrødder med Shanks-Tonelli algoritmen . 13
13
http://www.math.vt.edu/people/brown/doc/sqrts.pdf
34
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Som nævnt findes der dog en række specialtilfælde der kan lette beregningerne hvis
særlige betingelser er opfyldt.
Ifølge [6 ] s 101 kan følgende algoritme anvendes. Først tjekkes for om
legendresymbolet er 1 (jf. afsnittet om kvadratisk rest) og herefter for en række
specielle tilfælde, og afslutningsvist den generelle løsning hvor itereres der over en
række værdier for at nærme sig løsningen
for L=1
Case: p= 3,5,7 (mod 8)
If(p=3,7 (mod 8){
x=a^((p+1)/4) mod p
return x}
if(p=5(mod 8)){
x=a^((p+3)/8) mod p
c=x^2 mod p
if(c!=a mod p){x=x*2^((p-1)/4) mod p}
return x}
Case p=1 (mod 8)
Random integer d, så 2<=d<=p-1, d/p = -1 (legendre L = -1)
t ulige, p-1= 2^s*t
A=a^t mod p
D=d^t mod p
m=0;
for(0<=i<s){
if((A*D^m))^2^(s-1-i) = -1 mod p
m=m+2^i}
x=a^((t+1)/2)*D^(m/2) mod p
return x
Jeg har implementeret en løsning inspireret af Shanks og algoritmen herover –
kodeuddrag ses herunder.
protected void Button1_Click(object sender, EventArgs e)
{
BigInteger inputa = 0;
BigInteger modp = 0;
inputa = BigInteger.Parse(inputatxt.Text);
modp = BigInteger.Parse(inputptxt.Text);
BigInteger x=0;
int L = CalcLegendre(inputa,modp);
if (L != 1)
{
resulttxt.Text = "no solution";
}
else
{
x = CalcSquareMod(inputa, modp);
resulttxt.Text = x.ToString();
}
}//end button
35
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
private BigInteger CalcSquareMod(BigInteger a,BigInteger p){
//int count = 1;
BigInteger b = 0;
BigInteger c = 0;
BigInteger i = 0;
BigInteger l = 0;
BigInteger k = 0;
BigInteger q = 0;
BigInteger r = 0;
BigInteger s = 0;
BigInteger z = 0;
BigInteger n = 0;
if (((p % 8) == 3) || ((p % 8) == 7)) {
r = BigInteger.ModPow(a, (p + 1) / 4, p);
return r;
}
else if ((p % 8) == 5) {
r = BigInteger.ModPow(a, (p + 3) / 8, p);
q = (r * r) % p;
if (q != a) {
r = (r * BigInteger.ModPow(2, (p - 1) / 4, p))%p;
}
return r;
}
else{
k = p - 1;
//find init værdier for s og k så p= 2^s * (2*k + 1) -1
while(k.IsEven){
s++;
k /= 2;
}
k = (k - 1) / 2;
//find z så z IKKE er en kvadratisk rest mod p..!
z = 2;
while (CalcLegendre(z, p) == 1) {
z++;
}
//find init værdier for
r,n og c
r = BigInteger.ModPow(a,k+1,p);
n = BigInteger.ModPow(a,2*k+1,p);
c = BigInteger.ModPow(z,2*k+1,p);
//find løsning
while (n > 1)
{
//count++;
l = s;
b = n;
for (i = 0; i < l; i++) {
if (b == 1)
{
b = c;
s = i;
}
else
{
36
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
}
}
b = (b * b) % p;
}
c = (b * b) % p;
r = (b * r) % p;
n = (c * n) % p;
return r;
}//end p=1 mod 8
}//end calcSquareMod
private int CalcLegendre(BigInteger a,BigInteger p) {
//0 hvis p deler a, 1 hvis a er en kvadratisk rest mod p, -1 hvis det
er en ikke rest - nonresidue.
if ((a % p) == 0) {
return 0;
}
}
if (BigInteger.ModPow(a, (p - 1) / 2, p) == 1)
{
return 1;
}
return -1;
Punktet i uendelig - homogene koordinater
Et af problemerne med at håndtere beregninger på elliptiske kurver er punktet I
uendelig – det er en svær størrelse at håndtere. Der kan observeres flere forskellige
måder at gøre dette på, bl.a. ved hjælp af homogene 14 koordinator der skulle give en
matematisk solid basis for implementation.
Der ses også en række alternative metoder – en mindre elegant genvej og
kodemæssig ’lavpraktisk’ løsning kan f. eks være at lade punktet i uendelig være
repræsenteret ved et punkt der med sikkerhed ikke er eksisterende på kurven og så
lave særlige regler for multiplikation og addition med netop dette punkt.
Homogene koordinator I projektive rum
Man foretager en projektion fra 3d til 2d
Vi har at for R3 minus nulpunktet gælder der at to punkter P = (x, y, z) og
P’ = (x’, y’, z’) er ækvivalente hvis der findes et reelt tal λ forskellig fra nul således P =
λ·P’, i.e. x = λx’, y = λy’, z = λz’. Vi kan da skrive et element I det projektive plan, dvs
en ækvivalens klasse svarende til et almindeligt point (x, y, z) in R3 som [x : y : z].
Punkter på denne form kaldes også homogene koordinator.
[x:y:0] er punktet i uendelig, endelig punkter er [x:y:z]= [x/z:y/z:1]
Vi vil da homogenesere ligningen for en elliptisk kurve således: Vi tilføjer z indtil alle
dele af ligningen har same grad:
14
http://en.wikipedia.org/wiki/Projective_space
37
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
y2=x3 + Ax + B bliver til y2z=x3 + Axz2+Bz3
Beregninger I det projektive rum giver os en måde at arbejde med punktet i uendelig
– punktet bliver blot et specialplan i det tredimensionelle rum hvor parallelle linjer
mødes. Fordelen ved at arbejde med projektive koordinator er desuden at man
slipper for at beregne de omkostningsfyldte multiplikative inverser.
Jeg har i mine eksempler valgt den mindre elegante løsning.
‘Double and add’ algoritme
Da vi meget ofte har behov for at beregne værdien af nP for vilkårligt store n kan vi i
stedet for at lave n-1 successive additioner anvende den såkaldte ’double and add’
algoritme. Den bruger lidt samme princip som hurtig potensopløftning, vi bruger
binær ekspansion for tallet n og kan da beregne nP hurtigt. –
eksempel
n=947 . Det skrives således binært 1110110011 . Det betyder at
n=947 = 29+28+27+25+24+21+20
Hvorfor vi har at 947P = P+2P+16P+32P+128P+256P+512P. Det giver 9 fordoblinger
og 6 additions, hvilket er meget bedre end 946 additioner.
Vi har generelt følgende algoritme
fordoblings og additions algoritme:
1. input point P fra E(Fp) og n>=1
2. sæt Q=P og R=O (punktet I uendelig)
3. while n>0{
if n = 1 (mod2) sæt R= R+Q
sæt Q=2Q and n=n/2 (floor)}
4.return R (som nu er lig nP)
Hurtig potensopløftnings algoritmen
En let måde at beregne potenser modulært hvor man benytter den binære
repræsentation af potensen
Lille eksempel: 511 mod 13
Vi kan skrive 11 som en sum af potenser af 2 – altså binært
11 bliver til 1011, det betyder 11= 5^(23+21+20)= 5^(23)*52*5. Vi reducerer så
modulus 13 i hvert skridt og dermed forbliver tallene små. Det giver så 1*12*5= 60
mod 13= 8
38
christelbach.com - all rights reserved ©
Christel Bach©
11.
Kryptografi med Elliptiske Kurver v.1.5
Kryptografisk anvendelse af Elliptiske kurver
Principper bag Elliptic Diffie-Hellman nøgle udveksling
Elliptiske kurver kan anvendes til på en sikker måde at udveksle en fx en
krypteringsnøgle, der typiske efterfølgende anvendes til symmetrisk kryptering. Det
er et almindeligt setup, hvis hastighed er vigtigt. Den bagvedliggende ide er
asymmetrisk nøgleudveksling, hvor en ’bootstrap’ funktion – i dette tilfælde
punktaddition på EC, betyder lette beregninger den ene vej og meget svære
beregninger den anden vej.
Nøgleudveklingen ligner meget den klassiske Diffie-Hellman nøgleudveksling baseret
på DLP jf. Bilag B6 og er ganske ligetil. Beregninger til konkrete eksempler i
forbindelse med nøgleudveksling kan udføres og efterprøves i de tilhørende
eksempelapplikationer.
Offentligt tilgængelige parametre og beregninger
Domæne parametre vælges og offentliggøres:
Stort primtal p, Elliptisk kurve E over Fp og et punkt P i E(Fp)
Private beregninger
Alice
Bob
Vælger hemmelig nøgle nB (et heltal)
Vælger hemmelig nøgle nA (et heltal)
Beregner punktet QA som nA*P
Beregner punktet QB som nB*P
Offentlig udveksling af værdier
Alice sender QA til Bob (åben linie)---QA
QB ------Bob sender QB til Alice (åben linie)
Yderligere private beregninger
Alice
Bob
Beregner punktet nA*QB
Beregner punkter nB*QA
Den dermed delte hemmelighed er
nA*QB = nA*(nB*P)=nA*nB*P=nB*(nA*P)=nB*QA
Sikkerheden ligger således i at det er svært at finde nA*nB*P når nA*P og nB*P er
kendt. Essensen i det elliptisk kurve diskrete logaritme problem (ECDLP)
Nærmere undersøgelser viser at det er unødvendigt at sende begge koordinator for
QA og QB. De kan nøjes med at udveksle punkternes x værdier. jf s 298 [9].
Eksempel på Diffie-Hellman nøgleudveksling med P-192
Alice vælger sin hemmelige nøgle til at være:
nA: 45600302345679990129 og beregner nA*P =
QAx: 1894528013049453710734019818911225986194117239051331666114
39
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
QAy: 5622611255302448950252315476205327416275270401076249908551
Bob vælger sin hemmelige nøgle til at være:
nB:674839290001004592720994 og beregner nB*P=
QBx: 5065705273371010596137307787498960801693416542388365582997
QBy: 1398530282572627364052761296018227430013115282736611268301
De udveksler QA og QB gerne offentligt og kan nu hver især beregne den fælles
hemmelighed:
Alice beregner nA*QB=S1
S1x: 1755344126327670519259343913010319700785343903081333742686
S1y: 2373062010241911390714962920082029611707151511036195566445
Bob beregner nB*QA=S2
S2x: 1755344126327670519259343913010319700785343903081333742686
S2y: 2373062010241911390714962920082029611707151511036195566445
Som det ses er S1=S2 , den fælles hemmelighed til fx symmetrisk kryptering.
Hvis elliptiske kurver skal anvendes til nøgleudveksling skal der dog anvendes lidt
større kurver . ifølge SuiteB henvises der til NIST 800-56A der angiver kurverne P-256
eller P-384 til dette brug: Jf www.nsa.gov/ia/industry/crypto_suite_b.cfm (nu
http://www.nsa.gov/ia/programs/suiteb_cryptography/index.shtml)
Den kan findes på : http://csrc.nist.gov/groups/ST/toolkit/documents/SP80056Arev1_3-8-07.pdf
Dette dokument fastsætter blandt meget andet en lang række forskellige yderligere
protokolmæssige forhold omkring nøgleudveksling, som ikke vil blive beskrevet
nærmere her.
Principper bag EC ElGamal Public Key kryptosystem
Princippet bag ElGamal public key system (jf bilag B6) der er baseret på det diskrete
logaritme problem (DLP) kan direkte overføres til elliptiske kurver, altså samme
protokol blot baseret på ECDLP. Såvel P som M skal ligge på kurven.
Alice
Offentligt tilgængelige parametre og beregninger
Domæne parametre vælges og offentliggøres:
Stort primtal p, elliptisk kurve E over Fp, og et punkt P i E(𝐹𝐹𝐹𝐹)
Private Beregninger
Bob
Alice vælger som privat nøgle nA
og beregner offentlig nøgle
40
christelbach.com - all rights reserved ©
Christel Bach©
QA=nA*P
Kryptografi med Elliptiske Kurver v.1.5
Offentlig udveksling af værdier
Alice publicerer den offentlige nøgle QA
KRYPTERING
Private Beregninger
Bob vælger en klartekst M.
Han vælger et tilfældigt k
Han beregner
C1=k*P og
C2= M + k*QA
Offentlig udveksling af værdier
 Bob sender den krypterede besked ( C1, , C2 ) til Alice
DEKRYPTERING
Alice beregner
C2-nA*C1 = M
Private beregninger
At det giver den korrekte besked M ses ved simpel substitution:
C2-nA*C1 = M+k*QA - nA*k*P=M+k*nA*P - nA*k*P=M
Man vil kunne nøjes med blot at sende x koordinaten da y jo dermed allerede er
fastlagt – op til et fortegn – i praksis om y skal findes i den øvre eller nedre halvdel af
p. En patenteret version af ECC benytter netop denne egenskab og sender da blot x
og en ekstra bit med fortegnet.
En lang række implementationer af ECC er i øvrigt patenteret 15, især af Certicom 16.
EC El Gamal har det klare problem at der ikke er nogen oplagte måder at knytte
punkter på kurven til klartekst.
Koblitz har dog foreslået en metode beskrevet herunder.
Menezes og Vanstone har foreslået en modificeret version af ElGamal der
præsenteres under afsnittet ”MV ElGamal - Menezes – Vanstone varianten af
ElGamal”
At repræsentere klartekst med punkter på elliptiske kurver
Der er ikke nogle indlysende og ligefremme måder at mappe plaintekst direkte til
punkter på en kurve. Problemet er følgende:
Da der ikke er nogen polynominal tids algoritme til at fastlægge punkter på en kurve
vi det være besværligt forhånd kende punkterne på kurven og knytte beskeder til
disse.
Der er ingen garanti for at der på kurven findes et punkt så y2 = m3 + A*m + b mod p.
Faktisk er sandsynligheden for at det er tilfældet af størrelsesordnen ½ da cirka
halvdelen af alle heltal er kvadrattal modulus p.
15
16
http://en.wikipedia.org/wiki/ECC_patents
http://certicom.com/
41
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Dette kan ses ved følgende ræsonnement.
Kvadratisk rest
Vi har, at så længe vi beregner kvadratroden modulus et primtal p, findes præcis to
løsninger, nemlig b og –b. Antag af p er et primtal p>2. Vi vil da vide hvilke ikke-nul
elementer i Fp: {1,2,3,4…p-1} der er kvadrattal. Hvis der eksisterer et a i Fp* som er
kvadratisk har vi et b2=a og a har som nævnt præcist to kvadratrødder; b,-b..
Kvadrattallene i Fp* kan da alle beregnes som b2 mod p for b= 1,2,3,4,…(p-1)/2 idet
de resterende tal op til p-1 alle er kongruente med –b for et b mindre end p minus 1
halve. Så præcist halvdelen af elementerne i Fp* er kvadrattal. Kvadrattallene i Fp
kaldes kvadratisk rester (Quadradic residues) modulus p. De andre kaldes
nonresidues – ’ikkerester’.
Der er( p-1)/2 kvadratiske rester i Fp.
Legendresymbolet L= a((p-1)/2) mod p
Denne SKAL være lig med en, L=1, for at der findes en kvadratisk rest.
Legendre symbolet er størrelse der kan antage værdier 0,1 eller -1 afhængig af om a
er en kvadratisk rest eller ej. Er den 0 går a op i p. Jf [4]s. 43
Koblitz embedding af klartekst
Der findes således en statistisk metode udviklet af Koblitz jf [4]s.179 og [10] s 355
Metoden virker som følger:
Antag at det accepteres at der er en lille sandsynlighed for at beskeden ikke kan
mappes til et punkt. Denne sandsynlighed udtrykkes ½ ^K. Antag at (m+1)*K < p
Beskeden vil da være repræsenteret ved tallet x = m*K + j hvor der testes for
løsninger til y= (x3 + Ax + B)1/2 hvor j løber mellem 0 og K-1. Hvis der findes en sådan
kvadratrod vil beskeden m kunne embeddes som Pm = (x,y)
Beskeden vil kunne læses fra punktet ved at beregne m= x/K (floor)
Kryptering med koblitz embedding eksempel
Vælges f.eks en tolerance på en promille svarer det til K=10 idet ((1/2)^10)*100 ~
0.0977
Hvis vi vælger et eksempel med små tal for anskuelighedens skyld skal vi altså f.eks
gøre som følger:
Antag at p=173, punkt på kurven: P=(23,17)
E(Fp): Y2=X3 -3X + 128
Vi har dermed behov for at m*K + K < 173, altså m*10 + 10 < 173 dvs 0<=m<=16
Idet 16*10+10=170
Vi vælger beskeden m =7
x=m*K+j
42
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
7*10 + j=70 + j. Dvs x kan antage værdierne 70,71,72…79
Vi behøver derfor kun at loope igennem 10 mulige kandidater for at finde en løsning.
Vi leder naturligvis efter et resultat der er et kvadrattal mod q, dvs er en kvadratisk
rest mod p.
Vi har følgende mulige værdier for Y2 med de mulige x kandidater:
32,62,172,22, 137,4,148,56,80,53 ( i rækkefølge: 4,22,32,53,56,62,80,137,148,172)
Det ses straks at y2=4 for x=75 er en løsning. Altså punktet P=(75,2) må da være et
punkt på kurven der kan korrespondere beskeden med beskeden m= 7
Beskeden findes igen ved at tage x/K (floor). Vi har da 75/10= 7
Men der er stor sandsynlighed for at flere af de andre værdier er kvadratiske rester
modulus 173.
Vi finder ved trial-error at 39^2 mod 173 faktisk er 137. Vi vil da også kunne
anvende punktet: (74,39) og har fortsat at beskeden findes korrekt 74/10 = 7
Ligeledes findes at 54^2 mod 173 = 148. Så endnu et punkt fundet: (76,54)
Vi kan teste mulige kandidater op mod denne variant over eulers ligning hvis
resultat er det samme som legendre symbolet: k2=a mod p findes hvis og kun hvis
a^((p-1)/2) mod p ≡ 1
altså (Y2)^(172/2) mod 173; og hvis resultatet er 1 har vi en kandidat.
Følgende værdier giver -1 ( = 172) mod 173: 32, 62, 80, 53 og er derfor ikke
kandidater, det er derimod denne række da deres legendre symbol giver 1; 172, 22,
56, 137,4,148.
Vi finder ved denne metode at følgende værdier for y2 vil give en kvadratisk rest der
opfylder betingelserne.
Det er ikke trivielt at beregne kvadratrødder modulært, men der findes flere
forskellige måder.
Vi kan iflg Lagrange hvis p ≡ 3 (mod 4) beregne tallet som følger k≡+- a^((p+1)/4)
mod p
Vi tester da først for dette. 173 mod 4 =1. Alternativt har Legendre en løsning
hvis if p ≡ 5 (mod 8) {x=a^((p+3)/8) mod p, c=x^2 mod p, if(c!=a mod p){x=x*2^((p1)/4) mod p}return x}
Vi har at 173 mod 8 =5 og vil kunne anvende dette specialtilfæle. Vi regner det
således for a = 56
p=173, a= 56
43
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
x= 56^((173+3)/8) mod 173 = 109
109^2 mod 173 = 117. og da 117 er forskellig fra 109 beregner vi
x= 109* 2^(172/4)mod 173 = 70 og tjekker at 70^2 mod 173 = 56
Ifølge [6] er der ligeledes en række andre special tilfælde der kan gøre det lettere.
Jeg implementerede en løsning under afsnittet ”Kvadratrødder modulus p
implementation” og finder at
Sqrt(172) mod 173 = 80, Sqrt(22) mod 173 = 117, Sqrt(56) mod 173 = 70, Sqrt(137) mod
173= 134, Sqrt(148) mod 173 = 119 og Sqrt(4) mod 173= 171
Sidstnævnte er naturligvis det samme som –b.
MV ElGamal - Menezes – Vanstone varianten af ElGamal
Ifgl[9] s 343 har Menezas og Vanstone udviklet en variant af ElGamal der muliggør
anvendelse af EC til kryptering uden at knytte beskeder direkte til punkter og de
besværligheder der følger med dette.
Man vælger en besked M= m1,m2. og beregner produktet af dette og et punkt på
kurven.
Protokollen for denne MV-ElGamal variant er vist herunder:
Offentligt tilgængelige parametre og beregninger
Domæne parametre vælges og offentliggøres:
Stort primtal p, Elliptisk kurve E over 𝐹𝐹𝐹𝐹 og et punkt P i E(Fp)
Private Beregninger
Alice
Bob
Alice vælger som privat nøgle nA og
beregner
Q A = nA ∗ 𝐏𝐏
Offentlig udveksling af værdier
Alice publicerer den offentlige nøgle Q A 
KRYPTERING
Private Beregninger
Bob vælger en klartekst m1 og m2 modulus
p. Han vælger et tilfældigt k og beregner
𝐑𝐑 = k ∗ 𝐏𝐏
Han beregner
𝐒𝐒 = k ∗ Q A
og skriver det som
𝐒𝐒 = (xS , yS )
Han sætter
c1 = xS ∗ m1 mod 𝑝𝑝
c2 = yS ∗ m2 mod 𝑝𝑝
Offentlig udveksling af værdier
 Bob sender den krypterede besked (𝐑𝐑, c1, , c2 ) til Alice
DEKRYPTERING
Alice beregner
T = nA ∗ 𝐑𝐑
44
Private beregninger
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
og skriver
𝐓𝐓 = (xT , yT )
Hun sætter
m1′ = xT −1 c1 mod 𝑝𝑝
m′2 = yT −1 c2 mod 𝑝𝑝
og har da at
m1′ = m1 og at m′2 = m2
Vi kan vise at krypteringen virker således
Bevis for at 𝐦𝐦′𝟏𝟏 = 𝐦𝐦𝟏𝟏 og at 𝐦𝐦′𝟐𝟐 = 𝐦𝐦𝟐𝟐 :
−1
Vi har at (m′1 , m′2 ) = (�x−1
T ∗ c1 �, �yT ∗ c2 �) =
((𝑥𝑥𝑇𝑇−1 ∗ 𝑥𝑥𝑆𝑆 ∗ 𝑚𝑚1 ), (𝑦𝑦𝑇𝑇−1 ∗ 𝑦𝑦𝑆𝑆 ∗ 𝑚𝑚2 ))
Vi mangler da blot at vise at T=S
𝐓𝐓 = nA ∗ 𝐑𝐑 = nA ∗ k ∗ 𝐏𝐏 = QA ∗ k = 𝐒𝐒
Fordelen ved dette system er at de krypterede beskeder ikke er afhængige af
eksistensen af bestemte punkter på kurven.
Beskedudvidelse:
Sådanne systemer giver en udvidelse af beskedlængden og dermed også behov for
at sende mere information pr besked end længden af beskeden.
I tilfældet Koblitz får vi en firedobling da der for hver plaintekst m skal anvendes
koordinaterne m1,m2 og den krypterede besked c1,c2 består af fire tal da der til
hvert c knytter sig to koordinater. Ved i stedet at vælge at beskeden m ingen direkte
tilknytning har til punkter på kurven reduceres dette. Jf [9] s.300. Med MV ElGamal
vil man kunne nøjes med en fordobling da to beskeder giver fire punkter. Der findes
måder at optimere dette yderligere.
Herunder et lille gennemregnet eksempel hvor der benyttes P-192:
Eksempel:
Domæne parametre P-192
Alice vælger sin nøgle nA=42
QAx:4185472242164967416073535207017700391327566827942296643232
QAy:6153697814367168108673891119168116667577085838602601518070
Som besked M vælges: Vibevej2
Oversættelse fra klartekst til ASCII værdier kan let implementeres og et lille
eksempel på hvordan er vist i slutningen af dette afsnit.
45
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
oversat til char værdierne i ASCII tabellen 17får vi
86 105 98 101 118 101 106 50
kan normaliseres til
m1=086105098101
m2=118101106050
altså en besked M delt i en x og en y koordinat.
Det er klart at med denne banale oversættelse fra klartekst til ascii decimaltal, vil M
her kun kan antage et begrænset antal værdier og det vil være en sårbarhed der vil
være åben over for statistisk analyse.
Det vil også være hensigtsmæssigt i forbindelse med optimering af sådan et system,
at undersøge hvad der er mest effektivt; - at lave meget lange og store beregninger
med meget store tal frem for mindre tal hvor der itereres over flere punkt
beregninger. I dette eksempel krypteres kun via et gennemløb.
Bob vælger et tilfældigt k=666 og beregner k*P= R
Rx=3860888126715376297061837125523468217946653704297671234980
Ry=1713930569144474905671260344111335470105855823395511588834
Han beregner k*QA=S=666*QA=
Sx=1708963741076985658615763266160195183172716576861956067757
Sy=863850825861113597072455524978602376084698547032572545089
c1 og c1 skal da beregnes som:
da vi opererer med p-192 er
p =6277101735386680763835789423207666416083908700390324961279
c1=086105098101*Sx mod p
=4125119106641708631008410939537091809177032574604725655082 (Bcalc1)
c2=118101106050*Sy mod p
=1095172169333449301313221634686671435277573939186130217326 (Bcalc2)
Bob sender derfor til Alice følgende:
3860888126715376297061837125523468217946653704297671234980,
1713930569144474905671260344111335470105855823395511588834,
4125119106641708631008410939537091809177032574604725655082,
1095172169333449301313221634686671435277573939186130217326
17
http://en.wikipedia.org/wiki/ASCII - ASCII printable characters
46
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Alice kan nu læse den hemmelige besked således:
T= nA*R=42*R=
Tx:1708963741076985658615763266160195183172716576861956067757
Ty:863850825861113597072455524978602376084698547032572545089
hvilket i øvrigt ses at være det samme som Bob's S for k*Qa
m1 og m2 vil hun da beregne som
m1=(Tx)-1*c1 mod p
altså en modulus invers af Tx der kan beregnes til at være:
362597256794625975268988920526302302508782574301183531788
m1=362597256794625975268988920526302302508782574301183531788*c1 modp
=86105098101
Ty^-1=4313942180723358294434328075805847763990522353269117465080
m2=4313942180723358294434328075805847763990522353269117465080*c2 mod p
=118101106050
m1: 86105098101 normaliseres bagfra til 086 105 098 101
m2: 118101106050 der læses som 118 101 106 050
hvilket ses at være den korrekte besked.
Som det ses en det kun en lille del af beregningen der vedrører selve beskeden og
man vil altså let kunne transmittere lange beskeder når først kontakt er etableret
med domæne parametre og Alices udsendelse af QA og Alices modtagelse af R.
Alice behøver kun en gang i forbindelse med dekrypteringen af besked at foretage en
modulus invers – nemlig første gang hun skal beregne Tx^-1 og Ty^-1. Alle
efterfølgende beskeder beregnes blot som et multiplum af resultatet modulus p.
Det er afgørende at k IKKE anvendes igen i efterfølgende beregninger selv om det
kunne se ud som at man ved fortsat anvendelse af de samme private nøgler nA og k
og offentlige nøgler QA og R i kommunikationen mellem Alice og Bob kun var
beregningerne af c1, c2 og m1 og m2 der var nødvendige. men det giver
sammenhørende værdipar der vil introducere en stor sårbarhed i systemet. k er
altså en engangsnøgle.
Fra klartekst til ASCII værdier og fra ASCII til klartekst
En tekststreng kan nemt oversættes til talværdier fx med en indbygget ASCII
encoding funktion der anvendes her til demonstrationsbrug. Den har som output et
bytearray der uden yderligere oversættelse læses direkte i to- eller trecifrede heltal.
47
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
For at være sikker på at en længere ascii encoded streng korrekt oversættes til tekst
bagefter kan man separere karaktererne og kryptere dem enkeltvist, man kan
anvende en separator eller som her blot sikre at et hvert bogstav altid oversættes til
3 cifre. Tilsvarende kan resultaterne igen opdeles i bidder af 3 og oversættes til
karakterer.
Kodeuddrag:
//oversæt klartekst til ascii decimal tal
protected void translate_btn_Click(object sender, EventArgs e)
{
string m = inputmtxt.Text;
string result = "";
byte[] b = Encoding.ASCII.GetBytes(m);
foreach (byte c in b)
{
string cstr = c.ToString();
if (cstr.Length == 2) { cstr = "0" + cstr; }
result += cstr;
}
outasciitxt.Text = result;
}
//oversæt ascii decimaler til klartekst
protected void reversetranslate_btn_Click(object sender, EventArgs e)
{
//deling af tekststrengen så det går op med tre
string m1half = m1txt.Text;
string m2half= m2txt.Text;
//løsning af nul-som -første-tegn-fejl
if (m1half.Length % 3 != 0)
{
m1half = "0" + m1half;
}
if (m2half.Length % 3 != 0)
{
m2half = "0" + m2half;
}
string enc = m1half+m2half;
if (enc.Length % 3 == 0)
{
string display = "";
for (int i = 0; i <= enc.Length - 2; i += 3)
{
string subst = enc.Substring(i, 3);
int let = Convert.ToInt32(subst);
char c = (char)let;
display += c.ToString();
}
48
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
}
else
{
}
outmtxt.Text = display;
outmtxt.Text = "number of digits must be divisible by 3";
}
ECDSA – Digital Signatur med Elliptiske kurver
Signaturalgoritmen er standardiseret i FIPS-186-3 og IEEE 1363. Faktisk er de
tidligere nævnte NIST kurver og domæneparametre netop i FIPS-186-3 angivet med
henblik på digital signatur.
Protokollen består af fire algoritmer, domæneparameter generering, en nøgle
generering, algoritme til signering af dokument og verifikationsalgoritme. Skematisk
set kan ECDSA betragtes som herunder
Offentligt tilgængelige parametre og beregninger
Domæne parametre vælges og offentliggøres:
Elliptisk kurve E over 𝐹𝐹𝐹𝐹 og et punkt P i E(Fp) af stor primtalsorden (dvs stort q hvor q*P=𝒪𝒪)
Nøglegenerering
Alice
Enhver
Alice vælger som privat signeringsnøgle s ,
der skal være mindre end q-1
og beregner
V = s ∗ 𝐏𝐏
Offentlig udveksling af værdier
Alice publicerer sin offentlige verifikationsnøgle V 
Signering
Private Beregninger
Alice vælger et dokument d mod q
(feks hashværdien af et dokument)
Som engangsnøgle vælges et e mod q
Hun beregner R=e*P og sætter
S1=rx mod q og
-1
S2=(d+s*s1)*e mod q
Offentlig udveksling af værdier
Alice publicerer signaturen ( s1, , s2 ) 
Verifikation
Private beregninger
Bob – og enhver anden - kan nu beregne:
u1=d*s2-1 mod q og
u2=s1* s2-1 mod q
49
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Vi beregner nu u1*P + u2*V og verificerer at
x koordinaten af (u1*P + u2*QA) mod q =s1
At signaturens verifikation virker kan ses ved substitution:
u1*P + u2*QA=
d*s2-1*P+ s1* s2-1 *s*P=
d*((d+s*rx)*e-1)-1*P + rx((d+s*rx)*e-1)-1*s*P=
d*e*(d+s*rx)-1*P+rx*e*(d+s*rx)-1*s*P=
eP*(d+s*rx/ d+s*rx)=eP.
Og da vi netop har at x koordinaten af e, rx =s1 er signaturen verificeret.
Ifølge standarden der er specificeret i FIPS-186-2 skal beskeden hashes med en
kryptografisk sikker hashfunktion med en bitlængde mindre end q. Hashværdien kan
afkortes hvis den skulle være længere. Desuden sikres mod at x koordinaten for
Alices nøgle ikke er 0. Der testes i verifikationen ligeledes for om u1*P + u2*V skulle
give punktet i uendelig og er det tilfældet afvises signaturen.
Der skal naturligvis anvendes et sæt af de specificerede domæneparametre
herunder basepunktet P’s primiske orden.
Lille ECDSA eksempel
Vi vælger en kurve E(Fp):Y2=X3+231X+473 for p =17389
Vi har punktet P=(11259,11278) ordenen af punktet q =1321, dvs 1321*G=O.
Alices hemmelige nøgle s= 542, vi ser at 542 < 1321. Hun beregner
verifikationsnøglen V=8689, 1726
Dokumentet d=644 og bruger tilfældig nøgle e=847
Signaturen på dokumentet er da s1 = x koordinaten af (eP)=( 8417,8276), altså 8417
mod 1321, vi har da s1= 491
S2 er (m + s*s1)*e-1 mod q= (644+542*491)*847-1 mod 1321= 266766*170 mod
1321=290
S2=290. Signaturen er dermed (s1,s2)=491,290
Verifikation af signaturen:
u1=644*(290) -1 mod 1321 = 1305
u2=491*(290)-1 mod 1321=316
50
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Beregn 1305*P + 316*V = (9097,8279)+ (10752,10085)= (8417,8276)og x
koordinaten 8417 mod 1321 =491.
Hvilket også er s1. Dermed er signaturen verificeret.
ECDSA eksempel med P-192
Vi anvender P-192 og har da følgende parametre
p= 6277101735386680763835789423207666416083908700390324961279
Basepunktets koordinater er
Px = 602046282375688656758213480587526111916698976636884684818
Py = 174050332293622031404857552280219410364023488927386650641
og punktets orden er
q= 6277101735386680763835789423176059013767194773182842284081
Alice vælger som sin private nøgle s= 2012
Alice beregner og offentliggør sin verifikationsnøgle
V=(2922239241191941502284728959322335584196442148729153291377,
1502159992078275043300446768429050252602320077568505599434)
Et tænkt dokuments hashværdi viser sig at være d=13700000
Hun vælger et e= 117 og beregner R=eP og får at x koordinaten for den er:
R=1527582501009595379995457860700428877881691533865105226913,
4893605161761473125188711747930087679206868472008812551775
Vi har her at x koordinaten er mindre end q, dvs
s1=1527582501009595379995457860700428877881691533865105226913
og s2 der beregnet til at være
s2=(d+s*s1)*e-1 mod q =( 13700000 +
2012*1527582501009595379995457860700428877881691533865105226913)*
117-1 mod 6277101735386680763835789423176059013767194773182842284081.
Vi kan beregne 117-1 mod q til:
858407074924674292490364365562537984788676208298508346541 og får så
s2=2341099299562788751111958401647355403058072626470462149990
Signaturen s1,s2 offentliggøres da.
Vi kan så verificere signaturen ved at beregne
51
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
u1= d* s2-1 mod q =13700000*s2-1 mod q =
13700000*5389700900305434341950176528763606871832257565524323568776
mod q =
5043957816523352802764515449112470456583857224793495319585
u2= s1* s2-1 mod q
=1527582501009595379995457860700428877881691533865105226913*5389700900305
434341950176528763606871832257565524323568776 mod q =
1183029175760643805892065340635084470564090535081852173276
Vi beregner nu u1*P og u2*QA
Vi finder at u1*P=
(2755168697580953239077556897250970010965048760304207384993,
2244872401584975394146297467936750707360747183849247952249)
Og at u2*V=
(26937839670117915397077702248718703919341152429677728160,
4290995809728762263188768931302125326828385123373315121812)
De to punkter lægges sammen og vi får:
1527582501009595379995457860700428877881691533865105226913,
2244872401584975394146297467936750707360747183849247952249
Og vi ser at x koordinaten er identisk med s1 hvorfor signaturen hermed er
verificeret
12.
Implementation af MV ElGamal ECC
Generelt set har jeg valgt en simplificeret implementation der ikke drager nytte af de
fordele der f. eks er nævnt i afsnit 8 for optimerede beregninger på primlegemer, jeg
har ikke valgt at implementere homogeniserede koordinator eller andre mere
avancerede måder at tilgå emnet på. Alle beregninger foregår med heltal
repræsenteret i decimalform, for at fremme forståelsen for hvilke beregninger der
foregår.
Af samme grund er denne implementation på ingen måde optimeret. Jeg har
prioriteret anskuelighed og anvendelse af kendte rutiner.
Det er de samme grundlæggende rutiner - punktaddition og punktfordobling på
elliptiske kurver, der ligger til grund for de fleste rutiner.
52
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
I samlingen findes både små programmer man kan bruge til delberegninger og et
samlet system. Jeg har således lavet
•
•
Generel EC Calculator:
http://christelbach.com/ECCalculator.aspx
Kan bruges til addition og fordobling på kurver med selvvalgte parametre, med
vilkårligt store tal
•
•
NIST- kurve beregninger:
http://christelbach.com/ecc1.aspx
Kan bruges til addition og fordobling på alle NIST kurver baseret på primlegemer.
Kan f. eks bruges til nøgleudveksling.
•
•
Squareroot modulus p: http://christelbach.com/squaremod.aspx
Modulær multiplikativ invers: http://christelbach.com/calcmodinverses.aspx
Kodeeksempler på to sidste nævnte er allerede vist i tidligere afsnit.
•
MV Elliptic Curve ElGamal encryption/decryption:
http://christelbach.com/MVECC.aspx
MV Elliptic Curve EC encryption/decryption er en samlet løsning der kan kryptere og
dekryptere en indtastet værdi.
Den indeholder de fleste rutiner inkluderet i de øvrige applikationer derfor er det
den der er vedlagt i Bilag A1
Det er en halvautomatisk løsning hvor man kan se alle skridt undervejs i processen,
ligesom man kan vælge sine egne tal eller randomiserede tal – der også vises.
Jeg har valgt at kryptere beskeden i kun ET punkt, et gennemløb, og af samme grund
er der også grænser for beskedens størrelse.
Løsningen er kodet i C#.NET. Det betyder at der ikke vil være nogen nævneværdig
forskel på om koden publiseres som standalone windows applikation eller som
ASP.NET applikation tilgængelig via internettet. Jeg har valgt at vise mine eksempler i
den sidste form af hensyn til tilgængeligheden. Jeg viser kun backend delen, resten
er GUI og vil kunne hentes direkte på den angivne hjemmeside. Den del der vedrører
validering af input og exception håndtering vil ikke blive berørt. Koden er sine steder
ikke for køn, da den indeholder redundans her og der. Især i forbindelse med
indlæsning af parametre, da alle de mange enkeltdele af applikationen kan stå alene.
Der er basis for en efterfølgende oprydning og finpudsning. Der forestår et arbejde
dels med at fjerne redundans, tilføje noget validering og exception handling, opdele
beskeden så der iterativt kan krypteres længere beskeder. Ved næste større
omorganisering af koden forventer jeg at simplificere løsningen ved lave et kurve
objekt der så kan instantieres med passende parametre.
53
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Koden er vedlagt med kommentarer i bilag A1 og alle eksempler kan som nævnt ses
og afvikles på www.christelbach.com . Sitet er hostet af unoeuro.com der som en af
de få er begyndt at understøtte .NET 4.0
Løsningen vil senere også blive tilgængelig på www.christel.dk/crypto
13.
Pakkeløsninger, biblioteker og andre
implementationer
Illustrative implementationer af kryptografi med EC
Der findes en stor mængde af implementationer publiceret eller offentlig tilgængeligt på
nettet. Herunder blot et par udpluk.
Rosing har udgivet bogen ’Implementing Elliptic Curve Cryptography’ . Her er al kildekode i
C tilgængelig og en række interessant implementationsovervejelser. Ifgl Rosing selv er hans
algoritmer dog ikke udviklet med henblik på effektivitet men på anskueliggørelse.
Hans implementationer kan dog ikke anbefales ifølge en debat mellem en række debattører
på Usenet i Sci.Crypt.. Herunder D. Hankerson - medforfatteren til bogen Guide to Elliptic
Curve Cryptography[5].
Jf indlæg:
That is the book I *cannot* recommend to read. Rosing encourages all players in the
crypto world to pick their own curves at random (even without counting the points
on it). That is nonsense, and won't result in secure systems.
Bogen giver dog en fornemmelse af hvilke skridt der skal tages I forbindelse med en
implementation.
Et andet eksempel på illustrativ implementationen kan ses på hjemmesiden tilhørende Klaus
Reinhardt, Universitet i Tübingen.
Han har flere ’legetøjseksempler’ på elliptisk kurve kryptografi implementeret i Java liggende
her:
http://www2-fs.informatik.uni-tuebingen.de/~reinhard/krypto/English/english.html
og kildekode kan ses her:
http://www2-fs.informatik.uni-tuebingen.de/~reinhard/krypto/java/
Hans løsning er ikke baseret på meget store tal og nærmere studier af hans kode vil vise at
punktet i uendeligt er repræsenteret ved tallet 666,666 (!)
Der findes desuden en open source implementation skrevet i Pearl her:
http://search.cpan.org/~billh/Crypt-ECDSA-0.069/
54
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Support af Suite B i .NET
Certicom tilbyder en API løsning der muliggør Suite B niveau: ”Certicom Security
Builder API for .NET”
http://certicom.com/net
.NET har siden version 3.5 givet fuld understøttelse af diverse suite B algoritmer
Læs mere her på MSDN:
http://msdn.microsoft.com/en-us/library/bb332048.aspx
To relevante klasser er beskrevet her:
Digital Signatur med EC: Elliptic Curve Digital Signature Algorithm (ECDSA).
http://msdn.microsoft.com/enus/library/system.security.cryptography.ecdsacng.aspx
Diverse kryptografiske operationer med EC Diffie-Hellman
http://msdn.microsoft.com/enus/library/system.security.cryptography.ecdiffiehellmancng.aspx
Andre løsninger - Bouncy Castle
bouncycastle.org stiller et API til rådighed og dokumenterer brug af API til java
implementation af EC kryptografi her:
http://www.bouncycastle.org/wiki/display/JA1/Using+Elliptic+Curve
Eksempel på Digital Signatur med EC via Bouncy Castles API:
http://www.java2s.com/Tutorial/Java/0490__Security/DSAwithEllipticCurve.htm
14.
ECC versus RSA
Det er naturligvis relevant at overveje hvordan performance og sikkerhed på elliptisk
kurve kryptografi er sammenlignet med RSA. På rsa.com 18kan man finde et skema
over sammenlignelige værdier for nøglelængder. Her er et uddrag med de vigtigste
data
EC key
112
160
192
256
18
RSA key
430
760
1020
1620
Tid til at bryde
Mere end 5 minutter
600 måneder
3 millioner år
1016 år
http://www.rsa.com/rsalabs/node.asp?id=2088
55
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Til sammenligning er universets alder 13,7 109 år
Et af de karakteristika der findes ved ECC er at nøglelængen ikke behøver at være
nær så lang som en RSA nøgle for at yde den samme grad af sikkerhed.
En lang række forhold omkring domæneparametre, implementation, hardware osv., skal dog
tages i betragtning. I følge Lenstra og Verheul 19 er en RSA 1024-bit løsning sammenlignelig
med en ECC 160-bit. Tallene er dog ikke helt nye og skal derfor tages med forbehold.
Det vil selvfølgelig være relevant på optimerede implementationer af begge disse
public key systemer at foretage benchmark test, men da nærværende
implementation ikke er foretaget med henblik på optimering giver det ikke noget
validt sammenligningsgrundlag.
15.
Danske standarder på området for digital
signatur og sikker kommunikation:
Da Suite B jo er en amerikansk standardpakke udstukket af National Security Agency
kunne det være interessant at se hvilke standarder de danske myndigheder har sat
for sikkert kommunikation.
Det allernyeste på det danske sikkerhedsområde er den spritnye danske såkaldte
digitale signatur nemID. Det ligger uden for denne opgaves rammer at diskutere
protokollen den er implementeret under, men relevant ville være om den
bagvedliggende skulle være implementeret via RSA eller elliptiske kurver.
Jeg har derfor d. 17.07.2010 rettet forespørgsel til nemID for at høre i detaljer
hvilken digital signatur standard der anvendes. Jf Bilag C1. Dette resulterede i svar d.
19.07.2010 hvor der bliver gjort rede for en RSA løsning
” Konkret kan jeg oplyse, at certifikater til personer udstedes på baggrund af 2048
bit RSA-nøgler med SHA-256 som hash funktion, mens CA'ets rodnøgler er baseret på
4096 bit RSA-nøgler, også med SHA-256 som hash funktion. ”
Der synes altså ikke at være offentlige digitale signaturer baseret på ECCDSA i sigte i
Danmark.
Det har ikke været muligt at finde publicerede detaljerede standarder der er
sammenlignelige med Suite B med den danske myndigheder som afsender.
19
Artikel: “Selecting Cryptographic Key Sizes” fra Journal of Cryptology 14, 2001:
www.win.tue.nl/~klenstra/key.pdf
56
christelbach.com - all rights reserved ©
Christel Bach©
16.
Kryptografi med Elliptiske Kurver v.1.5
Afrunding og konklusion
Jeg har efter at have foretaget mange nedslag i den matematiske baggrund for
elliptiske kurve kryptografi konstateret at emnet på ingen måde er trivielt, at en
opgave af denne type med formidlingsperspektivet for øje, gør at jeg højst formår at
kratte lidt i overfladen.
Den matematiske dybde i emnet elliptiske kurver er et stort om komplekst område
med forgreninger ud i mange andre discipliner.
Opgaven kan sine steder virke udpenslet i overdreven grad. Andre steder ville man
formentlig gerne have set mere dybde end bredde, men såvel kompleksitetsgrad
som formidlingsperspektivet har været begrænsende for mine valg.
Men det vil forhåbentlig være muligt her at danne sig et indtryk af hvordan man kan
gøre kryptografisk brug af et så interessant emne som elliptiske kurver.
Efterskrift
Det har været en lang proces over flere år hvor der arbejdsmæssigt ofte ikke har
været plads til at fordybe sig i dette emne område. Det har betydet utallige
genopfriskninger undervejs af allerede erhvervet viden – og det har sænket tempoet
noget, og ind imellem også været desillusionerende.
Da jeg har undersøgt emnet kryptering med elliptiske kurver gennem så lang tid har
mængden af materialer også hobet sig op så det har været vanskeligt at prioritere og
vælge fra. Ustandseligt har jeg fundet nye spændende artikler, men også de helt
centrale artikler og standarder er blevet opdateret undervejs i nye udgivelser.
Meget har skullet skrives om flere gange og størstedelen af opgaven er dermed
blevet til inden for de sidste 3 måneder.
Opgaven bærer derfor måske præg af ikke at være skåret helt så skarpt og præcist
som man kunne ønske sig.
Det der for alvor satte skub i processen igen var da vi på Erhvervsakademi
Århus(tidligere Erhvervsakademiet - Århus Købmandsskole) fik godkendt
professionsbacheloruddannelserne i Webudvikling og Softwareudvikling og dermed
også fagmodulet Sikkerhed. Det har personligt givet et relevant perspektiv på
opgaven. Jeg har i det forgangne semester undervist i modulet Sikkerhed. Kryptologi
og kryptografi har naturligvis kun spillet en mindre rolle, niveauet og emnets
størrelse taget i betragtning jf. studieordning bilag C2, men det har været
motiverende at arbejde med sikkerhedsrelaterede emner og have et
formidlingsperspektiv på opgaven.
57
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Efter velafsluttet semester og eksaminer i faget var der ligesom kun en ting tilbage.
At få skrevet denne opgave.
Her er den så. Jeg troede at jeg nu ville være færdig med emnet Elliptiske Kurver –
men konstaterer at jeg dårligt er begyndt. ¤
58
christelbach.com - all rights reserved ©
Christel Bach©
17.
Kryptografi med Elliptiske Kurver v.1.5
Litteratur henvisninger
Litteratur
[1 ]Handbook of elliptic and hyperelliptic curve cryptography
af Cohen Frey, Avanzi, Doche, Lange, Nguyen, og Vercauteren.
[2 ]Eliptic Curves, Number Theory and Cryptography
af Lawrence C. Washington
[3 ]Implementing Elliptic Curve Cryptography
af Michael Rosing
[4 ]A Course in Number Theory and Cryptography. 2.Ed
af Neal Koblitz
[5 ]Guide to Elliptic Curve Cryptography
af Darrel Hankerson, Alfred Menezes og Scott Vanstone
[6 ]Prime Numbers, A Computational Perspective
af Richard Cradell og Carl Pomerance
[7 ]Number Theory, A programmer's Guide
af Mark Herkommer
[ 8]Advances in Elliptic Curve Cryptography
af Blacke, Seroussi og Smart, London Mathematical Society 2005. notes 317
[9] An introduction to Mathematical Cryptography
af Hoffstein, Pipher og Silverman
[10] Introduction to cryptography with coding theory, 2ed.
af Trappe og Washington
Artikler:
[11]FIPS PUB 186-2 app 6 : recommended elliptic curves for federal government
use. Nyere version FIPS-186-3 er visse steder anvendt i stedet.
[12]NIST-SP-800-56 samt csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.doc
[13] IEEE P1363 A.
[ 14]The Elliptic Curve Digital Signature Algorithm (ECDSA)
by Don Johnson, Alfred Menezes & Scott Vanstone
59
christelbach.com - all rights reserved ©
Christel Bach©
BILAG
18.
Kryptografi med Elliptiske Kurver v.1.5
Oversigt over bilag:
Kildekode til implementation af elliptisk kurve kryptografi
Bilag A1: kryptering/dekryptering med MV ElGamal EC
Supplerende matematisk pædagogisk materiale
Bilag B1: om algebraiske strukturer
Bilag B1A:Om isomorfier og afbildninger
Bilag B2: Grundlæggende om elliptiske kurver i R
Bilag B3: Diskriminanten og singulære punkter
Bilag B4: Mathematica visualisering
Bilag B5:Punktaddition i R, scriptkode
Bilag B6:ElGamal og DLP
Bilag B7:Kvadratroden af store tal
Bilag B8:RSA protokol m implementationseksempel
Bilag B9: Tidskompleksitet med eksempler på elliptiske kurver
Øvrige bilag:
Bilag C1: danske standarder, dialog med nemID
Bilag C2: studieordning for modulet ’Security’
19.
Kildekode til implementation af elliptisk
kurve kryptografi MV ElGamal ECC
Bilag A1
Kryptering og dekryptering af beskeder med NIST kurver baseret på
primlegemer og kurven Y^2=X^3+AX+B i C#.NET
Kildekoden her implementeres med passende kontroller i brugergrænsefladen.
60
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Løsning kan downloades i kildekode, og testes som webapplikation på
www.christelbach.com
using
using
using
using
using
using
using
using
using
using
System;
System.Collections.Generic;
System.Linq;
System.Web;
System.Web.UI;
System.Web.UI.WebControls;
System.Numerics;
System.Text;
System.Security.Cryptography;
System.Globalization;
namespace MVECCryptosystem
{
public partial class WebForm1 : System.Web.UI.Page
{
//domæneparametre for NIST kurver
BigInteger curv1inputB =
BigInteger.Parse("2455155546008943817740293915197451784769108058161191238065");
BigInteger curv1modp =
BigInteger.Parse("6277101735386680763835789423207666416083908700390324961279");
BigInteger curv1inputx1 =
BigInteger.Parse("602046282375688656758213480587526111916698976636884684818");
BigInteger curv1inputy1 =
BigInteger.Parse("174050332293622031404857552280219410364023488927386650641");
BigInteger curv2inputB =
BigInteger.Parse("1895828628556660800040866854449392641550468096867932107578723
4672564");
BigInteger curv2modp =
BigInteger.Parse("2695994666715063979466701508701963067355791626002630814351006
6298881");
BigInteger curv2inputx1 =
BigInteger.Parse("1927792911356629307111030803469948802683193421945244015664978
4352033");
BigInteger curv2inputy1 =
BigInteger.Parse("1992680875803447097019797437088874918420599199060394953763734
3198772");
BigInteger curv3inputB =
BigInteger.Parse("4105836372515214212932612978004726840911444101599372555483525
6314039467401291");
BigInteger curv3modp =
BigInteger.Parse("1157920892103562487626974469494075735300861434152903141955336
31308867097853951");
BigInteger curv3inputx1 =
BigInteger.Parse("4843956129390645175905258525279791420276294952604174799584408
0717082404635286");
BigInteger curv3inputy1 =
BigInteger.Parse("3613425095674979579858512791958788195661110667298501507187719
8253568414405109");
BigInteger curv4inputB =
BigInteger.Parse("2758019355995970587784901184038904809305690585636156852142870
7301988689241309860865136260764883745107765439761230575");
BigInteger curv4modp =
BigInteger.Parse("3940200619639447921227904010014361380507973927046544666794829
3404245721771496870329047266088258938001861606973112319");
61
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
BigInteger curv4inputx1 =
BigInteger.Parse("2624703509579968926862315674456698189185292349110921338781561
5900925518854738050089022388053975719786650872476732087");
BigInteger curv4inputy1 =
BigInteger.Parse("8325710961489029985546751289520108179287853048861315594709205
902480503199884419224438643760392947333078086511627871");
BigInteger curv5inputB =
BigInteger.Parse("1093849038073734274511112390766805569936207598951683748994586
3944959531161507350160137087375737596232485921322967063133094384525315910129121
42327488478985984");
BigInteger curv5modp =
BigInteger.Parse("6864797660130609714981900799081393217269435300143305409394463
4591855431833976560521225596406614545549772963113914808580371219879997166438125
74028291115057151");
BigInteger curv5inputx1 =
BigInteger.Parse("2661740802050217063228768716723360960729859168756973147706671
3684188029449964278084915450806277719023520942412250655586621571135455709168141
61637315895999846");
BigInteger curv5inputy1 =
BigInteger.Parse("3757180025770020463545507224491183603594455134769762486694567
7796155444774405563166912344050129455395621444445372894285225856667291965808101
24344277578376784");
BigInteger inputB, modp, inputx1, inputy1;
BigInteger inputA = -3;
protected void Page_Load(object sender, EventArgs e)
{
}
protected void DropDownList1_SelectedIndexChanged(object sender,
EventArgs e)
{
}
//beregner et pseudo random n
protected void Button1_Click(object sender, EventArgs e)
{
ntext.Text = pseudorandom();
}
protected void GetCurve() {
if (curveselectlist.SelectedValue == "192")
{
inputB = curv1inputB;
modp = curv1modp;
inputx1 = curv1inputx1;
inputy1 = curv1inputy1;
}
else if (curveselectlist.SelectedValue == "224")
{
inputB = curv2inputB;
modp = curv2modp;
inputx1 = curv2inputx1;
62
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
inputy1 = curv2inputy1;
}
else if (curveselectlist.SelectedValue == "256")
{
inputB = curv3inputB;
modp = curv3modp;
inputx1 = curv3inputx1;
inputy1 = curv3inputy1;
}
else if (curveselectlist.SelectedValue == "384")
{
inputB = curv4inputB;
modp = curv4modp;
inputx1 = curv4inputx1;
inputy1 = curv4inputy1;
}
else if (curveselectlist.SelectedValue == "521")
{
inputB = curv5inputB;
modp = curv5modp;
inputx1 = curv5inputx1;
inputy1 = curv5inputy1;
}
else
{
inputB = 42;
modp = 42;
inputx1 = 42;
inputy1 = 42;
}
}
//beregner Q=nG, G er basepunktet med koordinater fra NIST kurve
protected void Button2_Click(object sender, EventArgs e)
{
//læs domæneparametre ind for kurven
GetCurve();
BigInteger n = BigInteger.Parse(ntext.Text); //n i
brugergrænsefladen
bool bcheck = false;
//tjekker at punktet kan ligge på kurven
BigInteger calB = calcCurveB(inputA, inputx1, inputy1, modp);
if (calB == inputB) { bcheck = true; }
modp);
if (bcheck == true)
{
bchecklbl.Text = "";
BigInteger[] Res = calculatenP(inputx1, inputy1, n, inputA,
}
else
{
63
Qx3text.Text = Res[0].ToString();
Qy3text.Text = Res[1].ToString();
bchecklbl.Text = "your point was not on curve";
Qx3text.Text = "";
Qy3text.Text = "";
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
}
}
//beregner B værdien for angivet punt for at tjekke for hvilken B værdi
punktet kan ligge på kurven
private BigInteger calcCurveB(BigInteger parA, BigInteger coorx,
BigInteger coory, BigInteger fieldp)
{
BigInteger parB
BigInteger.ModPow(coorx, 3,
// B=y^2 -x^3 if (parB < 0)
{
parB = parB
}
return parB;
}
= (BigInteger.ModPow(coory, 2, fieldp) fieldp) - parA * coorx) % fieldp;
A*x mod N
+ fieldp;
//beregner lambda 1 for punktaddition - P + Q for P og Q forskellige
private BigInteger calcLambda1(BigInteger y2, BigInteger y1, BigInteger
x2, BigInteger x1, BigInteger modspace)
{
BigInteger lam1;
if ((x2 - x1) == 1 || ((x2 - x1) == -1))
{
lam1 = ((y2 - y1) / (x2 - x1)) % modspace;
}
else
{
lam1 = (y2 - y1) * CalcInverse((x2 - x1), modspace);
}
if (lam1 < 0)
{
lam1 = lam1 + modspace;
}
return lam1;
}
//beregner lambda 2 for punktaddition for to ens P - det samme som
punktfordobling P + P eller 2*P
private BigInteger calcLambda2(BigInteger x1, BigInteger y1, BigInteger
A, BigInteger modp)
{
BigInteger lam2;
if (((2 * y1).Sign == -1) && ((3 * x1 * x1 + A).Sign == -1) || (((2
* y1).Sign == 1) && ((3 * x1 * x1 + A).Sign == 1)))
{
lam2 = ((3 * x1 * x1 + A) * CalcInverse((2 * y1), modp)) %
modp;
}
else
{
lam2 = (-(3 * x1 * x1 + A) * CalcInverse((2 * y1), modp)) %
modp;
}
if (lam2 < 0) { lam2 = lam2 + modp; }
return lam2;
64
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
}
//beregner x værdi for punktaddition
private BigInteger calcXFinal(BigInteger Lambda, BigInteger x1,
BigInteger x2, BigInteger modp)
{
BigInteger bigX = (Lambda * Lambda - x1 - x2) % modp;
if (bigX < 0)
{
bigX = bigX + modp;
}
return bigX;
}
//beregner y værdi for punktaddition
private BigInteger calcYFinal(BigInteger Lambda, BigInteger x1,
BigInteger x3, BigInteger y1, BigInteger modp)
{
BigInteger bigY = ((Lambda * (x1 - x3)) - y1) % modp;//tjek her
if (bigY < 0) { bigY = bigY + modp; }
return bigY;
}
//beregner invers af et tal num modulus modp
private BigInteger CalcInverse(BigInteger num, BigInteger modp)
{
BigInteger x = 1;
BigInteger y = 0;
BigInteger a = modp;
BigInteger b = num;
BigInteger q, t;
BigInteger res;
while (b != 0)
{
t = b;
//q2 = Math.floor(a/t);
q = BigInteger.Divide(a, t);
b = a - q * t;
a = t;
t = x;
x = y - q * t;
y = t;
}
if (y < 0)
{
res = y + modp;
}
else
{
res = y;
}
return res;
}
//alternativ metode til beregning af invers
private BigInteger BinaryInverse(BigInteger a, BigInteger modp)
{
65
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
BigInteger u = a; BigInteger v = modp;
BigInteger r1 = 1; BigInteger r2 = 0;
while (u != 1 && v != 1)
{
while (u.IsEven)
{
u = u >> 1;
if (r1.IsEven) { r1 = r1 >> 1; } else { r1 = (r1 + modp) >>
1; }
}
while (v.IsEven)
{
v = v >> 1;
if (r2.IsEven) { r2 = r2 >> 1; } else { r2 = (r2 + modp) >>
1; }
r2 - r1; }
}
}
if (u >= v) { u = u - v; r1 = r1 - r2; } else { v = v - u; r2 =
}
if (u == 1) { return r1 % modp; } else return r2 % modp;
//double points
private BigInteger[] doublePoints(BigInteger x, BigInteger y,
BigInteger A, BigInteger modp)
{
BigInteger l2 = (calcLambda2(x, y, A, modp)) % modp;
//dontpanic.Text = l2.ToString();
BigInteger resl2x3 = (calcXFinal(l2, x, x, modp)) % modp;
BigInteger resl2y3 = (calcYFinal(l2, x, resl2x3, y, modp)) % modp;
}
BigInteger[] resPoint = { resl2x3, resl2y3 };
return resPoint;
//add points
private BigInteger[] addPoints(BigInteger x1, BigInteger y1, BigInteger
x2, BigInteger y2, BigInteger modp)
{
//håndtering af punktet i uendelig
BigInteger[] resPoint = { 0, 0 };
if (x1 == 0 && y1 == 0)
{
resPoint[0] = x2;
resPoint[1] = y2;
return resPoint;
}
else if (x2 == 0 && y2 == 0)
{
resPoint[0] = x1;
resPoint[1] = y1;
return resPoint;
}
else if ((x1 == x2) && (y1 != y2))
{
resPoint[0] = 0;
resPoint[1] = 0;
return resPoint;
}
else
{
66
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
BigInteger lam1 = 0;
BigInteger taeller = (y2 - y1);
BigInteger naevner = (x2 - x1);
if (naevner == 1)
{
lam1 = (y2 - y1) % modp;
}
else if (naevner < 0)
{
naevner = naevner + modp;
}
lam1 = (y2 - y1) * CalcInverse(naevner, modp);
if (lam1 <
{
lam1 =
}
BigInteger
BigInteger
0)
lam1 + modp;
finallam = lam1;
ny = y1 - (finallam * x1);
BigInteger x3 = ((finallam * finallam) - x1 - x2) % modp;
BigInteger y3 = (-((finallam * x3) + ny)) % modp;
if (y3 < 0) { y3 = y3 + modp; }
resPoint[0] = x3;
resPoint[1] = y3;
return resPoint;
}
}
//double and add algorithm
private BigInteger[] calculatenP(BigInteger x, BigInteger y, BigInteger
n, BigInteger A, BigInteger modp)
{
BigInteger[] Q = { x, y };
BigInteger[] R = { 0, 0 };
while (n > 0)
{
BigInteger t = BigInteger.ModPow(n, 1, 2);
if ((t) == 1)
{
R = addPoints(Q[0], Q[1], R[0], R[1], modp);
}
Q = doublePoints(Q[0], Q[1], A, modp);
n = n / 2;
}
BigInteger[] resPoint = { R[0], R[1] };
return resPoint;
67
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
}
//random generator
private static BigInteger GetRandom(int bitsize)
{
RandomNumberGenerator ran = RNGCryptoServiceProvider.Create();
int bytesize = bitsize / 8;
byte[] ranbytes = new Byte[bytesize];
//ex: Byte[20] giver 8 bit * 20 = 160 bit
//ex: Byte[2] giver 8 bit * 2 = 16 bit
//ex: Byte[128] giver 8 bit * 128 = 1024 bit
//fill byte array med kryptografisk stærke tilfældige bytes
ran.GetBytes(ranbytes);
}
//hæld random bytes i et bigInteger
BigInteger mynum = new BigInteger(ranbytes);
return mynum;
//oversæt klartekst til ascii decimal tal
protected void translate_btn_Click(object sender, EventArgs e)
{
string m = inputmtxt.Text;
string result = "";
byte[] b = Encoding.ASCII.GetBytes(m);
foreach (byte c in b)
{
string cstr = c.ToString();
if (cstr.Length == 2) { cstr = "0" + cstr; }
result += cstr;
}
}
outasciitxt.Text = result;
//BigInteger enc = BigInteger.Parse(result);
//oversæt ascii decimaler til klartekst
protected void reversetranslate_btn_Click(object sender, EventArgs e)
{
//deler strengen i hele multiplum af 3 og korrigerer for "0-fejl"
string m1half = m1txt.Text;
string m2half= m2txt.Text;
if (m1half.Length % 3 != 0)
{
m1half = "0" + m1half;
}
if (m2half.Length % 3 != 0)
{
m2half = "0" + m2half;
}
string enc = m1half+m2half;
//string enc = inputasciitxt.Text;
if (enc.Length % 3 == 0)
{
string display = "";
68
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
for (int i = 0; i <= enc.Length - 2; i += 3)
{
string subst = enc.Substring(i, 3);
int let = Convert.ToInt32(subst);
char c = (char)let;
display += c.ToString();
}
outmtxt.Text = display;
}
else
{
}
outmtxt.Text = "number of digits must be divisible by 3";
}
protected void encrypt_btn_Click(object sender, EventArgs e)
{
//BigInteger rank= BigInteger.Parse(inputk.Text);
//calculate R = k*G
//inlæs domæneparametre for kurven
GetCurve();
BigInteger k = BigInteger.Parse(inputk.Text); //k i
brugergrænsefladen
bool bcheck = false;
//tjekker at punktet kan ligge på kurven
BigInteger calB = calcCurveB(inputA, inputx1, inputy1, modp);
if (calB == inputB) { bcheck = true; }
modp);
if (bcheck == true)
{
bchecklbl.Text = "";
BigInteger[] Res = calculatenP(inputx1, inputy1, k, inputA,
}
else
{
}
rxtxt.Text = Res[0].ToString();
rytxt.Text = Res[1].ToString();
bchecklbl.Text = "your point was not on curve";
rxtxt.Text = "";
rytxt.Text = "";
//calculate S=k*Q
BigInteger altx1 = BigInteger.Parse(Qx3text.Text);
//eget indtastede x punkt nederst på siden
BigInteger alty1 = BigInteger.Parse(Qy3text.Text);
//eget indtastede y punkt nederst på siden
bool bcheck2 = false;
69
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
BigInteger sx = 0;
BigInteger sy= 0;
//tjekker at punktet kan ligge på kurven
BigInteger calB2 = calcCurveB(inputA, altx1, alty1, modp);
if (calB == inputB) { bcheck2 = true; }
if (bcheck2 == true)
{
bchecklbl.Text = "";
BigInteger[] Res = calculatenP(altx1, alty1, k, inputA, modp);
sx = Res[0];
sy = Res[1];
}
else
{
bchecklbl.Text = "your point was not on curve";
}
//besked indlæses
//sikrer at strengen deles to dele i chuncks af 3
string mes = outasciitxt.Text;
int let = (mes.Length)/3;
int halfsize = (let / 2) * 3;
string strm1 = mes.Substring(0, halfsize);
string strm2 = mes.Substring(halfsize, mes.Length - halfsize);
//c1 og c2
BigInteger
BigInteger
BigInteger
BigInteger
delen af krypteringen beregnes
m1 = BigInteger.Parse(strm1);
m2= BigInteger.Parse(strm2);
c1 = (sx * m1) % modp;
c2 = (sy * m2) % modp;
c1txt.Text = c1.ToString();
c2txt.Text = c2.ToString();
}
//random k
protected void rand_k_Click(object sender, EventArgs e)
{
inputk.Text = pseudorandom();
}
//pseudorandom funktion tester for bit størrelse
protected string pseudorandom() {
int bitsize = 192;
if (curveselectlist.SelectedValue == "192") { bitsize = 192;
else if (curveselectlist.SelectedValue == "224") { bitsize =
else if (curveselectlist.SelectedValue == "256") { bitsize =
else if (curveselectlist.SelectedValue == "384") { bitsize =
else if (curveselectlist.SelectedValue == "521") { bitsize =
else { bitsize = 16; }
}
70
}
224;
256;
384;
521;
}
}
}
}
BigInteger roll = GetRandom(bitsize);
if (roll < 0) { roll = roll * (-1); }
return roll.ToString();
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
protected void decrypt_btn_Click(object sender, EventArgs e)
{
//calculate T = n*R
//indlæsning af domæneværdier
GetCurve();
//indlæsning af privat nøgle
BigInteger n = BigInteger.Parse(ntext.Text); //n i
brugergrænsefladen
//indlæsning af den krypterede værdi R
BigInteger rx1 = BigInteger.Parse(rxtxt.Text);
BigInteger ry1 = BigInteger.Parse(rytxt.Text);
bool bcheck3 = false;
BigInteger tx = 0;
BigInteger ty= 0;
//tjekker at punktet kan ligge på kurven
BigInteger calB3 = calcCurveB(inputA, rx1, ry1, modp);
if (calB3 == inputB) { bcheck3 = true; }
if (bcheck3 == true)
{
bchecklbl.Text = "";
BigInteger[] Res = calculatenP(rx1, ry1, n, inputA, modp);
//værdi for T
tx = Res[0];
ty = Res[1];
}
else
{
bchecklbl.Text = "your point was not on curve";
//execption mangler for manglende værdi af T
}
//beregning for dekryptering m1 og m2
BigInteger txinv = CalcInverse(tx,modp);
BigInteger tyinv = CalcInverse(ty,modp);
//indlæsning af de krypterede c værdier
BigInteger c1=BigInteger.Parse(c1txt.Text);
BigInteger c2=BigInteger.Parse(c2txt.Text);
//beregning af m værdierne
BigInteger decm1=(txinv*c1)% modp;
BigInteger decm2=(tyinv*c2)% modp;
//udprint af m værdierne
m1txt.Text = decm1.ToString();
m2txt.Text = decm2.ToString();
}
}
71
}
christelbach.com - all rights reserved ©
Christel Bach©
72
Kryptografi med Elliptiske Kurver v.1.5
christelbach.com - all rights reserved ©
Christel Bach©
20.
Kryptografi med Elliptiske Kurver v.1.5
Supplerende pædagogiske matematiske bilag
Bilag B1
Kort oversigt over algebraiske strukturer:
Ring(+,*,e)
Ikke tom mængde med både addition(+) og multiplikation(*). Der gælder for disse:
+: kommutativ, associativ, neutralt element
*:associativ, distributiv, behøver ikke være kommutativ eller have neutralt element.
Legeme(+,*,e, a-1)
En ring der også er kommutativ og har neutralt element for både * og +
+:kommutativ, associativ, neutralt element
*:kommutativ, associativ, distributiv, neutralt element, invers (pånær for 0)
Gruppe(¤,e,a-1)
Ikke tom mængde med en operator(¤) neutralt element og invers
¤:Associativ, neutralt element, inverst element
Begreber:
Kommutativ: a ¤ b = b ¤ a. a,b, i algebraisk struktur og a¤b ligger I same struktur
Associativ: (x ¤ y) ¤ z = x ¤ (y ¤ z)
Distributiv: x * (y + z) = (x * y) + (x * z)
Inverst element: a¤b = b¤a = e
Neutralt element e vil sige: e ¤ a = a ¤ e = a, hvor ¤ blot betyder en operator.
Eks: 1*a=a*1=a og 0+a=a+0=a. 1 er altså her et neutral element under multiplikation
og 0 under addition.
Eksempel på gruppe: (Z + )
Eksempel på legeme: (F7)
(på engelsk Field) er Fp for p et primtal. Det består af alle naturlige tal inklusiv nul og
primtallet p-1. 0.1.2.3….p-1. Her altså 0,1,2,3,4,5,6
Eksempel på Ring (Z, +,*) og (Z/Zn, +,*), (Z[X], +,*)
Z[X] forstås som en polynomiumsring hvor koefficienterne ligger i Z
(a0+a1X+a2X2+…anXn)
73
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Bilag B1A
Homomorfi – endomorfi -isomorfi
homomorfi : en afbildning af en algebraisk struktur på en måde så strukturen er
bevaret
endomorfi: En endomorfi på E er en homomorfi givet ved rationelle funktioner
En homomorfi på elliptisk kurve over et lukket legeme er en afbildning af dette over i
sig selv?
� ) → 𝐸𝐸(𝐾𝐾
�)
𝛼𝛼: 𝐸𝐸(𝐾𝐾
Således at 𝛼𝛼(𝑃𝑃1 + 𝑃𝑃2) = 𝛼𝛼(𝑃𝑃1) + 𝛼𝛼(𝑃𝑃2)
Hvis funktionen 𝛼𝛼(𝑃𝑃) = 2𝑃𝑃 altså en punktfordobling, er der tale om en endomorfi
isomorfi: en homomorfi der er bijektiv
automorfi : en endomorfi der også er en isomorfi
Isomorfe grupper er i algebraisk forstand ens.
Afbildinger
Injektiv: En til en afbildning – entydig – ikke to elementer afbildes i samme element
Surjektiv: Hele A afbildes ind i hele B
Bijektiv: entydig korrespondance mellem alle elementer i A og B
http://www.mathsisfun.com/sets/images/function-mapping.gif
74
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Bilag B2:
Grundlæggende om Elliptiske kurver
– uddrag fra min eksamensopgave , Kryptologi B, om Lenstras Elliptiske kurve
metode (ECM)
En elliptisk kurve kan antage denne såkaldt korte Weierstrass form:
y 2 = x3 − Ax + B
(0.1)
Er kurverne defineret på de reelle tal får vi afbildninger som f.eks nedenstående:
Kurven er genereret i Maple med følgende kommando:
> restart:with(plots):with(numtheory):with(algcurves):
> implicitplot([y^2=x^3-5*x+4,y^2=x^3-2*x+12,y^2=x^35*x+5,y^2=x^3-5*x+3],x=-5..7,y=75
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
10..10,numpoints=6000,color=[blue,green,cyan,red],
legend=[E1,E2,E3,E4]);
Vi for langer dog at kurven skal være glat, dvs rødderne i kubikken skal være
forskellige dvs diskriminanten d ikke må være nul, dvs
d=
((r1 − r2 )(r1 − r3 )(r2 − r3 ))3 =
−(4 A3 + 27 B 2 ) ≠ 0
Addition af to punkter P og Q kan visualiseres således:
I grove træk er metoden altså følgende: Linien der forbinder de to punkter forlænges
til den skærer kurven et tredie sted og denne spejles. Adderes i stedet P+P vælges
tangentlinien i punktet P og denne forlænges ligeledes til den skærer kurven og
reflekteres.
Anvender vi den korte Weierstrass form (0.1) vil punktet P+Q få koordinater der
beregnes som følger:
P+Q:
x1 ≠ x2 og y1 ≠ y2 , altså P er forskellig fra Q så har vi at:
(0.2) x3 = m 2 − x1 − x2 , y3 = m( x1 − x3 ) − y1 hvor m er hældningen: m =−
y2 y1 / x2 − x1
Hvis P og Q er sammenfaldende, dog y1 ≠ 0 :
2P:
x3 m 2 − 2 x1 , y3 = m( x1 − x3 ) − y1 hvor hældningen i stedet beregnes som
(0.3) =
m 3 x12 + A / 2 y1
tangenten i punktet=
76
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Vi opererer ligeledes med et punkt i uendelig ∞ , repræsenteret ved en lodret linie.
Der gælder at P+Q= ∞ , hvis x1 = x2 men y1 ≠ y2 .
Der gælder ligeledes at P+ ∞ ,=P for alle P.
Punkterne på den elliptiske kurve opfylder betingelserne for en additiv abelsk gruppe
med identitetselement ∞ .
Gruppen består altså af mængden af punkter (x,y) der ligger i K x K som ligger på
kurven samt et punkt i uendelig, som jeg fra nu af vil benævne O
Når vi arbejder med grupper på Elliptiske kurver over et endeligt felt Fp er der
naturligvis ikke længere tale om en sammenhængende visuel glat kurve , men
nærmere en ”punktsky”
F.eks kan y 2 mod 23 = x 3 + 4x + 3 mod 23 visualiseres således:
Skalarmultiplikation af punkter er grundlæggende for elliptiske kurvers
kryptografiske anvendelse.
Et punkt P multipluceret med et tal k resulterer I et nyt punkt på kurven Q = kP.
Skalar multiplikation udføres ved en kombination af punkt addition og punktfordobling
Eksempel: Q= 11P = 2((2(2P)) + P) + P
77
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Bilag B3
Diskriminanten og singulære punkter
Til sammenligning ses her to kurver E5 og E6 der begge har diskiminanten lige med 0.
De karakteriske punkter hvor kurven har knæk kaldes singulære punkter.
> restart:with(plots):with(numtheory):with(algcurves):
> implicitplot([y^2=x^3-7*x+3,y^2=x^3-7*x+9,y^2=x^35*x+5,y^2=x^3-7*x-12,y^2=x^3-3*x+2, y^2=x^3],x=-5..7,y=10..10,numpoints=60000,color=[blue,green,cyan,red,black,o
range], legend=[E1,E2,E3,E4,E5,E6]);
78
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Bilag B4
Mathematica visualisering
I Mathematica kan elliptiske kurver visualiseres således:
Manipulate[{F, G} = { x^3 - a y^2 + b x y^2 + c x^2 y, A x + B};
Plot3D[{F, G}, {x, -8, 10}, {y, -30, 30}, PlotRange -> All,
PlotStyle -> {LightBlue, Green},
MeshFunctions -> Function @@@ {{{x, y, z}, (F - G)}}, Mesh -> {{0}},
MeshStyle -> Directive[{Red, Thick}],
Epilog -> {Inset[
Graphics[
Text[Style[
Column[{"intersection curve",
Row[{a y^2, " = ", x^3 + b x y^2 + c x^2 y - A x - B}]},
Center], {12, 12}, Black]], ImageSize -> 240], {Center,
Top}], Inset[
Graphics[
Text[Style[
Column[{"surface", Row[{Style["z", Italic], " = ", F}]}], {12,
12}, Black]], ImageSize -> 200], {0.3, .1}],
Inset[Graphics[
Text[Style[
Column[{"plane", Row[{Style["z", Italic], " = ", G}]}], {12,
12}, Black]], ImageSize -> 150], {0.85, .1}]}, Axes -> None,
PlotPoints -> 45, Boxed -> False, ImageSize -> {375, 375},
SphericalRegion -> True, ViewAngle -> \[Pi]/6],
Style["parameters of the plane", Bold],
Style[Row[{"z = A x + B"}], Bold],
{{A, 11, "A (rotation)"}, -10, 25, 0.5, Appearance -> "Labeled",
ImageSize -> Tiny},
{{B, 12, "B (translation)"}, -20, 50, .01, Appearance -> "Labeled",
ImageSize -> Tiny},
Style["\nparameters of the surface", Bold],
Style["z = \!\(\*SuperscriptBox[\"x\", \"2\"]\)-a \
\!\(\*SuperscriptBox[\"y\", \"2\"]\)+b x \!\(\*SuperscriptBox[\"y\",
\
\"2\"]\) + c \!\(\*SuperscriptBox[\"x\", \"2\"]\) y", Bold],
{{a, -1, "a"}, -2, 2, 0.01, Appearance -> "Labeled",
ImageSize -> Tiny},
{{b, 0, "b"}, -2, 2, 0.05, Appearance -> "Labeled",
ImageSize -> Tiny},
{{c, 0, "c"}, -5, 5, 0.2, Appearance -> "Labeled", ImageSize ->
Tiny},
Delimiter, TrackedSymbols -> Manipulate, ControlPlacement -> Left,
SynchronousUpdating -> False]
http://demonstrations.wolfram.com/RealEllipticCurves/
79
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Bilag B5
Punktaddition på R – kode eksempel i javascript
Simpelt demonstationseksempel på R, med værdier max 'integer' størrelse:
Der konstrueres passende felter i html dokument der matcher id'erne i denne kode.
Denne meget lille løsning tester IKKE for om punkterne overhovedet ligger på kurven
- det er på eget ansvar. Det er kun i tilfældet P1=p2 hvor y1 er forskellig fra nul at
kurvens koefficienter direkte indgår i additionsberegningen - og derfor der fejlkilden
skal findes.
fgl placeres i eksternt javascript:
window.onload= initForm;
function initForm(){
document.getElementById("ok").onclick = calcPoint;
}
function calcPoint(){
var x1= parseInt(document.getElementById("xx1").value);
var y1= parseInt(document.getElementById("yy1").value);
var x2= parseInt(document.getElementById("xx2").value);
var y2= parseInt(document.getElementById("yy2").value);
if((x2-x1) != 0 ){
var m = (y2-y1)/(x2-x1);
var x3 = (m*m)-x1-x2;
var y3= m*(x1-x3)-y1;
document.getElementById("r1").innerHTML="P3, (x3,y3) er "+x3+","+y3;
}
else if (((x2-x1) == 0) && ((y2-y1) != 0)){
alert("det er farligt at dividere med nul, P1 + P2 giver punktet i
uendelig");}
else if ((x2-x1)==0 && (y2-y1)==0){
if(y2 != 0){
var A= parseInt(document.getElementById("AA").value);
var m = ((3*x1*x1)+A)/(2*y1);
var x3 = (m*m)-2*x1;
var y3= m*(x1-x3)-y1;
document.getElementById("r1").innerHTML="P3, (x3,y3) er "+x3+","+y3;
}
else{
alert("P1 + P2 giver punktet i uendelig");
document.getElementById("r1").innerHTML="eternal sunshine in a
spotless mind";
}
}
else{
alert("noget gik helt galt");
document.getElementById("r1").innerHTML="42";
}
return false;
80
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Multiplicativ invers modulus p - kodeeksempel i javascript
JavaScript der implementerer euclids algoritme til at finde modulært invers
Anvend passende html elementer og referer til eksternt script med følgende:
window.onload= initForm;
function initForm(){
document.getElementById("ok").onclick = calcInverse;
}
function calcInverse(){
var n= parseInt(document.getElementById("nn").value);
var p= parseInt(document.getElementById("pp").value);
var x = 1;
var y = 0;
var a=p;
var b=n;
var q,t;
var res;
while (b != 0) {
t
q
b
a
t
x
y
}
if(y<0){
res= y+p;
}
else{
res=y;
}
=
=
=
=
=
=
=
b;
Math.floor(a/t);
a - q*t;
t;
x;
y - q*t;
t;
document.getElementById("r1").innerHTML="a^-1
return false;
er "+res;
}
81
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
BILAG B6
ElGamal og DLP
ElGamal protokollen giver en generel sikker måde at udveksle beskeder på ved
hjælp af offentligt tilgængelige nøgler og åbne linier. Protokollen baserer sig på en
matematisk trapdoor funktion. I Den klassiske ElGamal er denne Det Diskrete
Logaritmeproblem(DLP)over et endeligt legeme Fp. Altså populært sagt baseret på
at det er nemt at beregne gn mod p = x (hvor x er forskellig fra 0), men svært at
aflede n for kendte værdier af g p, og x..
p skal være et primtal og g skal være en primitiv rod 20 i Fp.
Vi skriver også at x= logg (h)
Protokollen ser ud som følger:
Offentligt tilgængelige parametre og beregninger
Domæne parametre vælges og offentliggøres:
Stort primtal p, og et element g, en primitiv rod i 𝐹𝐹𝐹𝐹
Private Beregninger
Alice
Bob
Alice vælger som privat nøgle a
For 1<=nA<=p-1og beregner offentlig nøgle
a
A=g mod p
Offentlig udveksling af værdier
Alice publicerer den offentlige nøgle A
KRYPTERING
Private Beregninger
Bob vælger en klartekst m.
Han vælger et tilfældigt k
Han beregner
c1=gk mod p og
c2= mAk mod p og
Offentlig udveksling af værdier
 Bob sender den krypterede besked ( c1, , c2 ) til Alice
DEKRYPTERING
Alice beregner
a -1
((c1) ) *c2 mod p = m
Private beregninger
Det kan man nemt verificere ved substitution giver det ønskede m således:
a -1
a -1
k*a -1
a k
((c1) ) *c2 mod p = ((gk) ) * m*Ak mod p = ((g ) * m* (g ) mod p =
k*a -1
((g
) * m* (ga*k) mod p =m
20
dvs dets orden skal være p-1. Vi har at en primitiv rod er en generator for Fp*, dvs g(p-1)=1 mod p
(fermats lille sætning) Med andre ord alle elementerne kan skrives på formen g0,g1,g2,g3,…g(p-2).
Eks: Vi har at i Z17 er ord(3)= 16 idet 316=1.
82
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Bilag B7:
Kvadratroden af store tal
public static BigInteger Sqrt(BigInteger n)
{
BigInteger rootn = n;
int count = 0;
int bitLength = 1;
while (rootn / 2 != 0)
{
rootn /= 2;
bitLength++;
}
bitLength = (bitLength + 1) / 2;
rootn = n >> bitLength;
BigInteger lastRoot = BigInteger.Zero;
do
{
if (lastRoot > rootn)
{
if (count++ > 1000)
{
return rootn;
}
}
lastRoot = rootn;
rootn = (BigInteger.Divide(n, rootn) + rootn) >> 1;
}
while (!((rootn ^ lastRoot).ToString() == "0"));
return rootn;
}
Bilag B8:
RSA protokol og implementation
Bob
Private Nøgler
Alice
Private beregninger
• Vælg hemmelige primtal p og q.
Beregn p*q=N .
• Beregn phi=(p-1)*(q-1)
• Vælg et e så gcd(e,phi)=1
Offentligt
Bob publiserer N og e 
Kryptering
83
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Private beregninger
• Hemmelig besked tallet m<N. Brug
Bob’s offentlige nøgle (N,e) til at
beregne
• me mod N = c
Decryption
Offentligt
 Send c til Bob over en åben linie
Private beregninger
• Beregn d så e*d=1 (mod phi)
• ( er lig med e-1 mod phi – kun muligt
fordi han kender p og q)
• Beregn cd mod N . Det giver
beskeden m
Hvorfor virker det?
Fordi der er svært at beregne m, selv om du kender me, e og N (DLP)
Fordi det er svært at finde p og q selv om du kender N, og dermed svært at beregne
phi, og dermed svært at finde et d så ed=1 mod phi.
Hvis først man får faktoriseret N, er det nemt at finde phi og dermed rimelig simpelt
at beregne d= e-1 mod phi.
e-1 mod phi findes KUN når gcd(e,phi)=1. Med andre ord modulær multiplikativ
invers eksisterer kun hvis e og phi er indbyrdes primiske.
Matematisk bevis
cd mod N = (me)d mod N= medmod N = medmod pq = m fordi ed=1 mod (p-1)(q-1)
betyder at ed=1+k(p-1)(q-1), har vi at medmod pq= m1+k(p-1)(q-1), mod pq=m*(m(p-1)(q1) k
) . og da vi ifgl euler har at m(p-1)(q-1)=1 mod pq når gcd(m,pq)=1 får vi at m*(m(p-1)(q1) k
) =m*1k mod pq = m
Lille implementationseksempel på RSA:
using
using
using
using
using
using
using
using
System;
System.Collections.Generic;
System.Linq;
System.Web;
System.Web.UI;
System.Web.UI.WebControls;
System.Numerics;
System.Security.Cryptography;
namespace rsatoy
{
public partial class _Default : System.Web.UI.Page
{
BigInteger N;
BigInteger phi;
84
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
BigInteger efactor;
BigInteger rann, ranb;
protected void Button3_Click(object sender, EventArgs e)
{
BigInteger ranp = makeprime();
inputp.Text = ranp.ToString();
}
protected void Button4_Click(object sender, EventArgs e)
{
BigInteger ranq = makeprime();
inputq.Text = ranq.ToString();
}
protected BigInteger makeprime(){
bool isprime = false;
}
while(isprime == false){
rann= randomize();
ranb=randomize();
isprime= primalitytest(rann, ranb);
}
Trace.Write("rann equals " + rann);
return rann;
protected BigInteger randomize() {
int size = Convert.ToInt32(intbit.Text);
return GetRandom(size);
//return GetRandom(8);
}
//random generator
private static BigInteger GetRandom(int bitsize)
{
RandomNumberGenerator ran = RNGCryptoServiceProvider.Create();
int bytesize = bitsize / 8;
byte[] ranbytes = new Byte[bytesize];
//ex: Byte[20] giver 8 bit * 20 = 160 bit
//ex: Byte[128] giver 8 bit * 128 = 1024 bit
ran.GetBytes(ranbytes);
}
//hæld random bytes i et bigInteger
BigInteger mynum = new BigInteger(ranbytes);
if (mynum < 0) {
mynum = mynum * (-1);
}
return mynum;
//Miller Rabin primtalstest statistisk metode
protected bool primalitytest(BigInteger n, BigInteger b){
BigInteger i, q, r, t;
if (n.IsEven)
85
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
{
return false;
}
if (BigInteger.GreatestCommonDivisor(b, n) > 1) {
return false;
}
q = n - 1;
for (t = 0; q.IsEven; t++)
{
q >>= 1;
}
}
if ((r = BigInteger.ModPow(b, q, n)) != 1) {
for (i = 0; i < t - 1; i++) {
if (r != n - 1)
{
r = (r * r) % n;
}
else {
break;
}
}
}
if (r == 1 || r == n - 1)
{
return true;
}
else {
return false;
}
//beregner invers af et tal num modulus modp
private BigInteger CalcInverse(BigInteger num, BigInteger modp)
{
BigInteger x = 1;
BigInteger y = 0;
BigInteger a = modp;
BigInteger b = num;
BigInteger q, t;
BigInteger res;
while (b != 0)
{
t = b;
//q2 = Math.floor(a/t);
q = BigInteger.Divide(a, t);
b = a - q * t;
a = t;
t = x;
x = y - q * t;
y = t;
}
if (y < 0)
{
res = y + modp;
}
else
{
res = y;
86
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
}
return res;
}
protected void Button1_Click(object sender, EventArgs e)
{
BigInteger p = BigInteger.Parse(inputp.Text);
BigInteger q = BigInteger.Parse(inputq.Text);
N = p * q;
genN.Text = N.ToString();
phi = (p - 1) * (q - 1);
showphi.Text = phi.ToString();
efactor = makeprime();
BigInteger gcd = BigInteger.GreatestCommonDivisor(phi, efactor);
if (gcd == 1)
{
gene.Text = efactor.ToString();
}
else
{
}
gene.Text = "something went wrong, try again";
}
protected void Button5_Click(object sender, EventArgs e)
{
BigInteger mes = BigInteger.Parse(inputm.Text);
BigInteger keyN = BigInteger.Parse(genN.Text);
if (mes < keyN)
{
BigInteger efac = BigInteger.Parse(gene.Text);
BigInteger ciffer = BigInteger.ModPow(mes, efac, keyN);
genc.Text = ciffer.ToString();
}
else {
genc.Text = "message must be smaller than N";
}
}
protected void Button6_Click(object sender, EventArgs e)
{
BigInteger efac = BigInteger.Parse(gene.Text);
BigInteger p = BigInteger.Parse(inputp.Text);
BigInteger q = BigInteger.Parse(inputq.Text);
phi = (p - 1) * (q - 1);
BigInteger d = CalcInverse(efac, phi);
gend.Text = d.ToString();
N = p * q;
87
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
BigInteger c = BigInteger.Parse(genc.Text);
BigInteger clear = BigInteger.ModPow(c, d, N);
genm.Text = clear.ToString();
}
}
}
Bilag B9
Tidskomplexitet med regneeksempler på elliptiske kurver
Tidskomplexiteter
O(1) Konstant tid. Oprationens varighed er uafhængig af mængden af input.
O(N) Tiden for operationen vokser lineært med mængden af input.
O(N2) Kvadratisk tid. Tre gange så meget input giver ni gange så lang behandlingstid.
O(log2 N) Logaritmisk tid. Tidsforbruget stiger logaritmisk med mængden af input.
O((log n)k) Polylogaritmisk tid. Potens af Logaritmisk tid for en kontant k.
O(Nt) for Polynominal tid. -endeligt tal t - ex: O(N8).Tiden vokser med fast eksponent.
O(tN) - Eksponential tid - endeligt tal t ex O(8N). Tiden vokser eksponentielt med mængden.
MIPS – antal millioner instruktioner pr sekund
2010 tal: Intel Core i7 Extreem Edition i980EE 3.3 GHz - 147,600 MIPS
Computeralderens barndom 1972: IBM system 370 - model 158-3 - 1 MIPS jf
http://en.wikipedia.org/wiki/File:PPTMooresLawai.jpg
Tid
Universets alder er 13,7 Mia år, det kan beregnes til at være
432.330.242.400.000.000 sekunder. Jf
http://www.calculateme.com/Time/Years/ToSeconds.htm
88
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Beregninger af up-to-date hurtig intel core: 147600 MIPS *S =
63811943778240000000000000000 instruktioner siden bigbang
Alle efterfølgende beregninger af tidskompleksitet er naturligvis op til en konstant faktor.
Eksempel: At lede efter kvadrattal
O(p) hvor p = 6277101735386680763835789423207666416083908700390324961279
Antag at vi skal undersøge alle værdier af x op til p for lede efter matchende kvadrattal(finde
punkter på en elliptisk kurve). Det er en meget ineffektiv algoritme der løses i tiden O(p) jf
side 12 i rapporten.
Antag at der skal 100 instruktioner til for at undersøge ovenstående og man kan beregne
med følgende hastighed 147,600 MIPS, og derfor har vi at der kan beregnes meget groft
1476 M kvadrattals beregninger pr sekund
Dvs vi har da 6277101735386680763835789423207666416083908700390324961279
instruktioner/1.476.000.000 instruktioner pr sekund =
4.252778954*10^48 sekunder. Universets alder er 432.330.242.400.000.000 sekunder altså
Det er 9.836875927*10^30 gange universets alder.
Med andre ord en ret ineffektiv algoritme
Eksempel: Antallet af punkter der beregnes med Schoofs algoritme tidskompleksitet
Polylogaritmisk tid: O((log p)^6) ~=192^6 =50.096.498.540.544
(-da jeg går ud fra der er tale om logaritme med grundtallet 2.) Hvilket ses at være betydelig
kortere tid end O(p)
Kan man med optimering klemme den ned på O(logp)^5 er tallet 260.919.263.232
Altså en fuldstændig realistisk størrelse at beregne.
Eksempel – Pollards Rho metode:
Side 15. pollards rho metode kan løses i tiden O(sqrt(N)) hvor N er gruppens orden.
Vi har fx #E(F2^163)=
11692013098647223345629473816263631617836683539492
Jf s 12.
Dvs Pollards Rho metode kan finde en løsning for n for Q=nP i tiden
Sqrt(11692013098647223345629473816263631617836683539492)=
3.419.358.580.004.036.860.274.165 ~ 3,4*10^24
Man skal altså til enhver tid sørge for at ikke bare gruppens orden men kvadratroden af
gruppens orden har en størrelse så det ikke er attraktivt at anvende Pollards Rho metode til
at løse ECDLP
Antag at vi skal bruge 1000 operationer pr tilfældige paring og test af dette pars eventuelle
match.
89
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Vi har så 147600000 parringer pr sekund. Med andre ord vil løsning kunne forventes at
findes efter 2.3*10^16sekunder hvilket synes sikkert i betragtning af at 4.3*10^17 - er
universets alder.
Kan man lave en tabel over tP på en NIST kurve?
Da alle domæneparametre jo er kendte?
Nej Tidskomplexiteten ved at genneregne hver eneste værdi for hvert eneste punkt
er jo O(N) og der vil tage O(N) tid, og ikke nok med det, det vil tage enorme
mængder af storage kapacitet at gemme informationerne for slet ikke at snakke om
at slå op i disse bjerge af data.
21.
Øvrige bilag:
Bilag C1:
Danske standarder
forespørgsel er sendt til [email protected] - nemID 17.07 2010
Spørgsmål til implementation af nemID - valg af digital signatur standard?
Jeg forstår på udmeldinger i pressen af der anvendes niveau 4 i fips-140-2 men der synes ikke at være
tilgængelig information om hvilken bagvedliggende digital signatur standard der anvendes jf. fips_1863.pdf
Jeg vil derfor høre om det er muligt at få nærmere information om dette og har en række spørgsmål
herunder jeg håber I kan være behjælpelige med.
Anvendes der RSA til den digitale signatur og hvis ja hvilken nøglelængde er der da tale om?: 1024 eller
fx 2048? Hvilken hash funktion benyttes til verifikation?
Eller anvendes der i stedet Elliptisk kurve cryptografi til den digitale signatur (ECDSA) ?
Hvis ja, hvilke kurver er valgt - er de valgt blandt de i NSAs Suite B - NIST anbefalede kurver (NIST-IEEE
Standard 1363-2000), og hvis ja, hvilke bitlængde er der valgt? Hvilke øvrige public domæne parametre
anvendes?
Hvordan finder verifikation for domæneparametre og pseudorandomisering sted?
Hvordan forholder implementationen generelt sig til de i Suite B, - FIPS-186-3 beskreven Digital
signatur standarder?
Hvis det ikke er muligt at få disse oplysninger, er det så en del af sikkerhedsproceduren ikke at
offentliggøre domæneparametre og hvilken bagvedliggende kryptologi der baseres på?
90
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Den amerikanske standard Suite B anvendes efterhånden bredt og en del af troværdigheden til
systemet er baseret på at standardvalg og specifikation er offentliggjorte. Det er i mange
internationale sammenhænge et krav at en kryptografisk løsning lever op til suiteB standarder, og jeg
er derfor interesseret i hvilke overvejelser en dansk offentlig løsning har gjort sig i denne retning.
Jeg håber meget I kan hjælpe og takker mange gange på forhånd
refs:
http://csrc.nist.gov/publications/fips/fips140-2/fips1402.pdf
http://csrc.nist.gov/publications/fips/fips186-3/fips_186-3.pdf
med venlig hilsen
Christel Bach
Lektor i Design, Interaktion og Sikkerhed
Erhvervsakademi Århus
Svar fra Ministeriet for Videnskab, Teknologi og Udvikling 19.07.2010
Kære Christel Bach,
Tak for din henvendelse.
NemID udstedes, ligesom den gamle digitale signatur, i henhold til de såkaldte OCES
certifikatpolitikker, der findes offentligt tilgængelige på
https://www.signatursekretariatet.dk/certifikatpolitikker.html. Via OCES
certifikatpolitikkerne er der etableret en standard for certifikatudbydernes håndtering af
certifikaterne og for indholdet i disse. Certifikatpolitikkerne, der har været til høring hos alle
interesserede parter, udstikker det sikkerhedsniveau, der som minimum skal overholdes, hvis
certifikatudbyderne vil kalde sig OCES-CA.
Konkret kan jeg oplyse, at certifikater til personer udstedes på baggrund af 2048 bit RSAnøgler med SHA-256 som hash funktion, mens CA'ets rodnøgler er baseret på 4096 bit RSAnøgler, også med SHA-256 som hash funktion.
Derudover kan du læse videre i "OCES-personcertifikatpolitik version 4.0" via ovenstående
link, som er den version, NemID til det offentlige udstedes i henhold til.
Jeg håber det var svar på dit spørgsmål, ellers er du velkommen til at vende tilbage.
Med venlig hilsen
Morten Steen Tambour Jacobsen
Fuldmægtig, Cand.polyt.
Center for Digital Signatur
Direkte telefon: + 45 3337 9131
E-mail: [email protected]
Ministeriet for Videnskab,
Teknologi og Udvikling
IT- og Telestyrelsen
Holsteinsgade 63
DK-2100 København Ø
Telefon: +45 3545 0000
Fax: +45 3545 0010
91
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
E-mail: [email protected]
www.itst.dk
Bilag C2
Studieordning
Studieordning for modulet ’Security’, et valgmodul under uddannelserne
Professionsbachelor i Webudvikling og Professionsbachelor i Softwareudvikling ved
Erhvervsakademi Århus.
4.9 Security (optional module) (10 ECTS)
Purpose
The purpose is to make the student able to implement security analysis, propose
solutions and action plans, conducting implementation of resolutions and participate
in the ongoing management.
Objectives Knowledge
Operating system security
The objective is that the student must:
• have knowledge of principles for access control in operating systems
•
be able to explain how to maintain the operating system, in terms of updates
and "disaster recovery"
Security Techniques
The objective is that the student must:
• be able to explain the general principles of cryptography, including
symmetric and asymmetric encryption as well as the difference between weak
and strong encryption keys
•
•
•
•
92
be able to explain other security techniques more or less based on
cryptographic principles, including Digital Signature Certificates and Message
Digest
be aware of some widely used cryptographic standards (e.g. AES and RSA)
be able to explain the use of VPN
have extensive knowledge of security used on the World Wide Web, including
SSL and SSH
christelbach.com - all rights reserved ©
Christel Bach©
Kryptografi med Elliptiske Kurver v.1.5
Wireless Security
The objective is that the student must:
• have knowledge of the specific threats and problems in wireless
communications
•
be able to explain how best to secure wireless communications, including the
use of encryption, MAC address validation and authentication
Firewalls
The objective is that student must:
• be able to explain the operation of various types of firewalls, including
filtering routers and application firewalls
•
have knowledge of IDS - Intrusion Detection Systems
Application Security
The objective is that student must:
• know the general, overall threats that should be taken into account in
applications, and implement solutions to counter these threats
Skills
Security Analysis
The objective is that the student must:
• be able to explain and categorize the major security threats and the related
safety techniques
•
•
•
be able to prepare plans for physical security, redundant systems, backup
strategies and monitoring mechanisms to detect security breaches
be able to prepare a security policy
be able to conduct a security assessment, including:
o identifying the IT system's assets and defining the requirements for
their protection
o identifying threats
o risk analysis
o implementing parts of the security system
o preparing an action plan for what to do at a security breach
Operating system security
The objective is that the student must:
• be able to provide guidelines for how to achieve good password protection
•
be able to develop guidelines for controlling access to files and resources
Application Security
The objective is that student must:
• be able to identify the need to incorporate application-specific safety
programs
Competences
The student will gain competences in:
• monitoring developments within the security area in order to identify new
threats and the products and techniques for tackling these and already
existing threats
•
93
implementing / advising on the development of solid security applications
christelbach.com - all rights reserved ©
Christel Bach©
94
Kryptografi med Elliptiske Kurver v.1.5
christelbach.com - all rights reserved ©