kryptografi med elliptiske kurver - christelbach.comchristelbach.com/masteropgave_final1_5.pdf ·...

Christel Bach© Kryptografi med Elliptiske Kurver v.1.5

1 christelbach.com - all rights reserved ©

Kryptografi med Elliptiske kurver med perspektiv til Suite B

CHRISTEL BACH

KRYPTOLOGI C, MASTERPROJEKT, 2010

MASTER I KRYPTOLOGI

ÅRHUS UNIVERSITET



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å pohlig-hellmann 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.



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



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



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. KILDEKODE TIL IMPLEMENTATION AF ELLIPTISK KURVE KRYPTOGRAFI MV ELGAMAL ECC 60

Kryptering og dekryptering af beskeder med NIST kurver baseret på primlegemer og kurven Y^2=X^3+AX+B i C#.NET .............................................. 60

20. 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. ØVRIGE BILAG: ..................................................................................................... 90



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.com1

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 KryptologiB2

1 http://demonstrations.wolfram.com/RealEllipticCurves/ 2 http://christel.dk/krypto/Den_elliptiske_faelde-kopi.pdf

http://www.christelbach.com/�

http://demonstrations.wolfram.com/RealEllipticCurves/�

http://christel.dk/krypto/Den_elliptiske_faelde-kopi.pdf�



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.



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 guide3 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

http://www.nsa.gov/ia/_files/nist-routines.pdf�



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.



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 F2

m 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 .



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å F2

n, 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.



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:



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: 15541351137805832567355695254588151253139246935172245297183499990119263318817690415492 for k=409 er antallet af punkter: 1322111937580497197903830616065542079656809365928562438569297580091522845156996764202693033831109832056385466362470925434684 for k=571 er antallet af punkter 7729075046034516689390703781863974688597854659412869997314470502903038284579120849072535914090826847338826851203301405845094699896266469247718729686468370014222934741106692

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



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



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



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*p

k.

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(Fp

k) 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. her5

5 http://en.wikipedia.org/wiki/Index_calculus_algorithm

http://en.wikipedia.org/wiki/Index_calculus_algorithm�



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

http://mathworld.wolfram.com/ChineseRemainderTheorem.html�



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



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,88*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/

http://csrc.nist.gov/publications/fips/fips186-3/fips_186-3.pdf�

http://csrc.nist.gov/publications/fips/fips186-3/fips_186-3.pdf�

http://www.nsa.gov/ia/_files/ecdsa.pdf�




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 FIPS-186-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 =

39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319

𝑝𝑝 = 2521 − 1 =

6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151

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+View+(eSales)_Standards_IEEE&mem_type=Customer&SWEHo=sbwsweb.ieee.org&SWETS=119271365



standard implementation der ville virke på ethvert primtal.

Detaljer omkring denne optimering vil fremgå af guiden 9hørende til Suite B, samt af FIPS-186-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

Hvis vi modulerer det med 𝑝𝑝=2192−264−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




Det ses altså at være langt enklere at regne via de optimerede rutiner.

Binære legemer F2

163= 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.



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



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

http://www.schneier.com/blog/archives/2005/02/sha1_broken.html�



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).



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.



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

http://www.certicom.com/index.php/net�



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 10011001 11010010 10111011 10111111 11001011 00100101 00111000 01010100 00101101 11001101 01011111 10110000 01111000 10110110 11101111 01011111 00111101 01101111 11100010 11000111 01000101 11011110 01100101

Den første markerede del af tallet er de 31 mindst betydende cifre :R0, direkte fra beregningen sha1(S)



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.



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 00000101 01101100 01111110 00010001 11011101 01101000 11110100 00000100 01101001 11101110 01111111 00111100 01111010 01111101 01110100 11110111 11010001 00100001 00010001 01100101 00000110 11010000 00110001 00100001 10000010 10010001 11111011

Det ses at det matcher!

R1



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:



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.



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

http://www.extremeoptimization.com/�



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

http://www.math.vt.edu/people/brown/doc/sqrts.pdf�



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



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 {



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 homogene14 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

http://en.wikipedia.org/wiki/Projective_space�



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



11. 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 nA (et heltal)

Beregner punktet QA som nA*P

Vælger hemmelig nøgle nB (et heltal) 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



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/SP800-56Arev1_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.


Stort primtal p, elliptisk kurve E over Fp, og et punkt P i E(𝐹𝐹𝑝𝑝) Private Beregninger

Alice Bob Alice vælger som privat nøgle nA og beregner offentlig nøgle

http://www.nsa.gov/ia/industry/crypto_suite_b.cfm�

http://www.nsa.gov/ia/programs/suiteb_cryptography/index.shtml�

http://csrc.nist.gov/groups/ST/toolkit/documents/SP800-56Arev1_3-8-07.pdf�

http://csrc.nist.gov/groups/ST/toolkit/documents/SP800-56Arev1_3-8-07.pdf�



QA=nA*P 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 Private beregninger

Alice beregner C2-nA*C1 = M

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 patenteret15, især af Certicom16.

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 http://en.wikipedia.org/wiki/ECC_patents 16 http://certicom.com/



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



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^((p-1)/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



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:


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 QA = nA ∗ 𝐏𝐏

Offentlig udveksling af værdier Alice publicerer den offentlige nøgle QA

KRYPTERING Private Beregninger

Bob vælger en klartekst m1og m2 modulus p. Han vælger et tilfældigt k og beregner 𝐑𝐑 = k ∗ 𝐏𝐏 Han beregner 𝐒𝐒 = k ∗ QA 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


Alice beregner T = nA ∗ 𝐑𝐑



og skriver 𝐓𝐓 = (xT, yT) Hun sætter m1′ = xT

−1c1 mod 𝑝𝑝 m2′ = yT

−1c2 mod 𝑝𝑝 og har da at m1′ = m1 og at m2

′ = m2

Vi kan vise at krypteringen virker således

Bevis for at 𝐦𝐦𝟏𝟏′ = 𝐦𝐦𝟏𝟏 og at 𝐦𝐦𝟐𝟐

′ = 𝐦𝐦𝟐𝟐:

Vi har at (m1′ , m2

′ ) = (�xT−1 ∗ c1�, �yT

−1 ∗ 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.



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

http://en.wikipedia.org/wiki/ASCII�



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.



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(); }



outmtxt.Text = display; } else { 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


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 S2=(d+s*s1)*e-1 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



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



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



u1= d* s2-1 mod q =13700000*s2

-1 mod q =

13700000*5389700900305434341950176528763606871832257565524323568776 mod q =

5043957816523352802764515449112470456583857224793495319585

u2= s1* s2-1 mod q

=1527582501009595379995457860700428877881691533865105226913*5389700900305434341950176528763606871832257565524323568776 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.



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.

http://christelbach.com/ECCalculator.aspx�

http://christelbach.com/ecc1.aspx�

http://christelbach.com/squaremod.aspx�

http://christelbach.com/calcmodinverses.aspx�

http://christelbach.com/MVECC.aspx�



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/


http://www.christel.dk/crypto�

http://www2-fs.informatik.uni-tuebingen.de/~reinhard/krypto/English/english.html�

http://www2-fs.informatik.uni-tuebingen.de/~reinhard/krypto/java/�

http://search.cpan.org/~billh/Crypt-ECDSA-0.069/�



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/en-us/library/system.security.cryptography.ecdsacng.aspx Diverse kryptografiske operationer med EC Diffie-Hellman http://msdn.microsoft.com/en-us/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 RSA key Tid til at bryde 112 430 Mere end 5 minutter 160 760 600 måneder 192 1020 3 millioner år 256 1620 1016 år

18 http://www.rsa.com/rsalabs/node.asp?id=2088

http://certicom.com/net�

http://msdn.microsoft.com/en-us/library/bb332048.aspx�

http://msdn.microsoft.com/en-us/library/system.security.cryptography.ecdsacng.aspx�

http://msdn.microsoft.com/en-us/library/system.security.cryptography.ecdsacng.aspx�

http://msdn.microsoft.com/en-us/library/system.security.cryptography.ecdiffiehellmancng.aspx�

http://msdn.microsoft.com/en-us/library/system.security.cryptography.ecdiffiehellmancng.aspx�

http://www.bouncycastle.org/wiki/display/JA1/Using+Elliptic+Curve�

http://www.java2s.com/Tutorial/Java/0490__Security/DSAwithEllipticCurve.htm�

http://www.rsa.com/rsalabs/node.asp?id=2088�



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

http://www.win.tue.nl/~klenstra/key.pdf�



16. 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.



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. ¤



17. 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



BILAG

18. 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.



Løsning kan downloades i kildekode, og testes som webapplikation på www.christelbach.com

using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.UI; using System.Web.UI.WebControls; using System.Numerics; using System.Text; using System.Security.Cryptography; using 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("18958286285566608000408668544493926415504680968679321075787234672564"); BigInteger curv2modp = BigInteger.Parse("26959946667150639794667015087019630673557916260026308143510066298881"); BigInteger curv2inputx1 = BigInteger.Parse("19277929113566293071110308034699488026831934219452440156649784352033"); BigInteger curv2inputy1 = BigInteger.Parse("19926808758034470970197974370888749184205991990603949537637343198772"); BigInteger curv3inputB = BigInteger.Parse("41058363725152142129326129780047268409114441015993725554835256314039467401291"); BigInteger curv3modp = BigInteger.Parse("115792089210356248762697446949407573530086143415290314195533631308867097853951"); BigInteger curv3inputx1 = BigInteger.Parse("48439561293906451759052585252797914202762949526041747995844080717082404635286"); BigInteger curv3inputy1 = BigInteger.Parse("36134250956749795798585127919587881956611106672985015071877198253568414405109"); BigInteger curv4inputB = BigInteger.Parse("27580193559959705877849011840389048093056905856361568521428707301988689241309860865136260764883745107765439761230575"); BigInteger curv4modp = BigInteger.Parse("39402006196394479212279040100143613805079739270465446667948293404245721771496870329047266088258938001861606973112319");




BigInteger curv4inputx1 = BigInteger.Parse("26247035095799689268623156744566981891852923491109213387815615900925518854738050089022388053975719786650872476732087"); BigInteger curv4inputy1 = BigInteger.Parse("8325710961489029985546751289520108179287853048861315594709205902480503199884419224438643760392947333078086511627871"); BigInteger curv5inputB = BigInteger.Parse("1093849038073734274511112390766805569936207598951683748994586394495953116150735016013708737573759623248592132296706313309438452531591012912142327488478985984"); BigInteger curv5modp = BigInteger.Parse("6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151"); BigInteger curv5inputx1 = BigInteger.Parse("2661740802050217063228768716723360960729859168756973147706671368418802944996427808491545080627771902352094241225065558662157113545570916814161637315895999846"); BigInteger curv5inputy1 = BigInteger.Parse("3757180025770020463545507224491183603594455134769762486694567779615544477440556316691234405012945539562144444537289428522585666729196580810124344277578376784"); 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;



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; } if (bcheck == true) { bchecklbl.Text = ""; BigInteger[] Res = calculatenP(inputx1, inputy1, n, inputA, modp); Qx3text.Text = Res[0].ToString(); Qy3text.Text = Res[1].ToString(); } else { bchecklbl.Text = "your point was not on curve"; Qx3text.Text = ""; Qy3text.Text = "";



} } //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(coory, 2, fieldp) - BigInteger.ModPow(coorx, 3, fieldp) - parA * coorx) % fieldp; // B=y^2 -x^3 - A*x mod N if (parB < 0) { parB = parB + fieldp; } return parB; } //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;



} //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) {



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; } //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 {



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 < 0) { lam1 = lam1 + modp; } BigInteger finallam = lam1; BigInteger 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;



} //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 = "";



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; } if (bcheck == true) { bchecklbl.Text = ""; BigInteger[] Res = calculatenP(inputx1, inputy1, k, inputA, modp); rxtxt.Text = Res[0].ToString(); rytxt.Text = Res[1].ToString(); } else { 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;



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 delen af krypteringen beregnes BigInteger m1 = BigInteger.Parse(strm1); BigInteger m2= BigInteger.Parse(strm2); BigInteger c1 = (sx * m1) % modp; BigInteger 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 = 224; } else if (curveselectlist.SelectedValue == "256") { bitsize = 256; } else if (curveselectlist.SelectedValue == "384") { bitsize = 384; } else if (curveselectlist.SelectedValue == "521") { bitsize = 521; } else { bitsize = 16; } BigInteger roll = GetRandom(bitsize); if (roll < 0) { roll = roll * (-1); } return roll.ToString(); }



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(); } } }



20. 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)



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

http://www.mathsisfun.com/sets/images/function-mapping.gif�



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:

2 3y x 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^3-5*x+5,y^2=x^3-5*x+3],x=-5..7,y=-



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

3 3 21 2 1 3 2 3(( )( )( )) (4 27 ) 0d r r r r r r A B= − − − = − + ≠

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:

1 2x x≠ og 1 2y y≠ , altså P er forskellig fra Q så har vi at:

(0.2) 23 1 2x m x x= − − , 3 1 3 1( )y m x x y= − − hvor m er hældningen: 2 1 2 1/m y y x x= − −

Hvis P og Q er sammenfaldende, dog 1 0y ≠ :

2P:

(0.3) 23 12x m x= − , 3 1 3 1( )y m x x y= − − hvor hældningen i stedet beregnes som

tangenten i punktet 21 13 / 2m x A y= +



Vi opererer ligeledes med et punkt i uendelig ∞ , repræsenteret ved en lodret linie. Der gælder at P+Q=∞ , hvis 1 2x x= men 1 2y y≠ .

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 pF er der naturligvis ikke længere tale om en sammenhængende visuel glat kurve , men nærmere en ”punktsky”

F.eks kan 2 3y mod 23 = x + 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



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^3-5*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,orange], legend=[E1,E2,E3,E4,E5,E6]);



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/

http://demonstrations.wolfram.com/RealEllipticCurves/�



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;



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 = b; q = Math.floor(a/t); b = a - q*t; a = t; t = x; x = y - q*t; y = t; } if(y<0){ res= y+p; } else{ res=y; } document.getElementById("r1").innerHTML="a^-1 er "+res; return false; }

http://hyperelliptic.blogspot.com/2009/05/multiplicative-inverse-modulus-p.html�



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 rod20 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=ga 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


Alice beregner ((c1)a)-1*c2 mod p = m

Det kan man nemt verificere ved substitution giver det ønskede m således: ((c1)a)-1*c2 mod p = ((gk)a)-1* m*Ak mod p = ((gk*a)-1* m* (ga) k mod p =

((gk*a)-1* 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.



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 Alice Private Nøgler

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



Private beregninger • Hemmelig besked tallet m<N. Brug

Bob’s offentlige nøgle (N,e) til at beregne

• me mod N = c

Offentligt Send c til Bob over en åben linie

Decryption

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)(q-

1))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)(q-

1))k =m*1k mod pq = m

Lille implementationseksempel på RSA:

using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.UI; using System.Web.UI.WebControls; using System.Numerics; using System.Security.Cryptography; namespace rsatoy { public partial class _Default : System.Web.UI.Page { BigInteger N; BigInteger phi;



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)



{ 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;



} 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;



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

http://en.wikipedia.org/wiki/File:PPTMooresLawai.jpg�

http://www.calculateme.com/Time/Years/ToSeconds.htm�



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.



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_186-3.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å?

mailto:[email protected]�



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 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.

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

https://webmail.efif.dk/OWA/redir.aspx?C=aa3bd61e435d4e8593e7f4e7bbbf448b&URL=http%3a%2f%2fcsrc.nist.gov%2fpublications%2ffips%2ffips140-2%2ffips1402.pdf�

https://webmail.efif.dk/OWA/redir.aspx?C=aa3bd61e435d4e8593e7f4e7bbbf448b&URL=http%3a%2f%2fcsrc.nist.gov%2fpublications%2ffips%2ffips186-3%2ffips_186-3.pdf�

https://webmail.efif.dk/OWA/redir.aspx?C=ea7fd9eda6d143d485db20c57c295d1b&URL=https%3a%2f%2fwww.signatursekretariatet.dk%2fcertifikatpolitikker.html�

https://webmail.efif.dk/OWA/redir.aspx?C=ea7fd9eda6d143d485db20c57c295d1b&URL=mailto%3amstj%40itst.dk�



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

• 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

https://webmail.efif.dk/OWA/redir.aspx?C=ea7fd9eda6d143d485db20c57c295d1b&URL=http%3a%2f%2fwww.itst.dk%2f�



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

• implementing / advising on the development of solid security applications

kryptografi med elliptiske kurver - christelbach.comchristelbach.com/masteropgave_final1_5.pdf ·...

Documents