Een efﬁciënte hardware-implementatie van het McEliece

Een efficiënte hardware-implementatievan het McEliece publieke sleutelcryptosysteem

Jeroen Delvaux

Thesis voorgedragen tot hetbehalen van de graad van Masterin de ingenieurswetenschappen:

elektrotechniek, optieGeïntegreerde elektronica

Promotor:Prof. dr. ir. Ingrid Verbauwhede

Assessoren:Prof. dr. ir. Wim Dehaene

Dr. ir. Frederik Vercauteren

Begeleiders:Ir. Leif Uhsadel

Ir. Gauthier Van Damme

Academiejaar 2009 – 2010

c© Copyright K.U.Leuven

Zonder voorafgaande schriftelijke toestemming van zowel de promotor(en) als deauteur(s) is overnemen, kopiëren, gebruiken of realiseren van deze uitgave of gedeel-ten ervan verboden. Voor aanvragen tot of informatie i.v.m. het overnemen en/ofgebruik en/of realisatie van gedeelten uit deze publicatie, wend u tot ESAT, Kas-teelpark Arenberg 10 postbus 2440, B-3001 Heverlee, +32-16-321130 of via [email protected].

Voorafgaande schriftelijke toestemming van de promotor(en) is eveneens vereist voorhet aanwenden van de in deze masterproef beschreven (originele) methoden, pro-ducten, schakelingen en programma’s voor industrieel of commercieel nut en voorde inzending van deze publicatie ter deelname aan wetenschappelijke prijzen of wed-strijden.

Voorwoord

Deze thesis kon slechts tot stand komen dankzij de steun en hulp van verscheidenemensen. Dank gaat uit naar mijn promotor, Prof. Ingrid Verbauwhede, voor hetaanreiken van het thesisonderwerp en tevens voor het ter beschikking stellen van eenzeer nuttig gebleken handboek. Bijzondere dank gaat uit naar mijn begeleiders Ir.Leif Uhsadel en Ir. Gauthier Van Damme voor kun kritische houding ten opzichtevan het geleverde werk en het verstrekken van de nodige bijsturing in dit verband.Hun advies en hulp hebben een duidelijke meerwaarde betekend. Dank gaat uit naarmijn medestudenten om de PC-klasuren wat amusanter te maken. Tenslotte wil ikmijn vrienden en familie bedanken voor hun morele steun.

Jeroen Delvaux

i

Inhoudsopgave

Voorwoord iSamenvatting ivLĳst van figuren en tabellen vLijst van afkortingen en symbolen vii1 Inleiding 1

1.1 Publieke sleutel cryptografie . . . . . . . . . . . . . . . . . . . . . . . 11.2 Thesis-doelstellingen . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Voorgaand werk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.4 Het ontwerpproces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Het McEliece-algoritme 52.1 Eindig veld rekenkunde . . . . . . . . . . . . . . . . . . . . . . . . . 52.2 Foutcorrigerende codes . . . . . . . . . . . . . . . . . . . . . . . . . . 62.3 McEliece als publieke sleutel cryptosysteem . . . . . . . . . . . . . . 92.4 Veiligheid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.5 Reductie van geheugengebruik . . . . . . . . . . . . . . . . . . . . . . 122.6 Vergelijking met andere publieke sleutel algoritmes . . . . . . . . . . 132.7 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3 Ontwerp op systeemniveau 173.1 MicroEliece FPGA-implementatie . . . . . . . . . . . . . . . . . . . . 173.2 Parallelle neutralisatie van scramblingmatrix S. . . . . . . . . . . . . 193.3 Hardware-software co-design . . . . . . . . . . . . . . . . . . . . . . . 203.4 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

4 Generatie sleutelmatrices 274.1 Inverse scramblingmatrix S−1 . . . . . . . . . . . . . . . . . . . . . . 274.2 Inverse permutatiematrix P−1 . . . . . . . . . . . . . . . . . . . . . . 334.3 Generatorveelterm g(z) . . . . . . . . . . . . . . . . . . . . . . . . . 344.4 Publieke generatormatrix G . . . . . . . . . . . . . . . . . . . . . . . 364.5 Niet-uniforme kansverdeling problematiek . . . . . . . . . . . . . . . 364.6 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5 Eindig-veldoperaties 395.1 Basis van de eindig-veldoperaties . . . . . . . . . . . . . . . . . . . . 395.2 Keuze van de irreduceerbare veelterm. . . . . . . . . . . . . . . . . . 40

ii

Inhoudsopgave

5.3 Vermenigvuldiging . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415.4 Vermenigvuldiging met het element x . . . . . . . . . . . . . . . . . 425.5 Kwadraat en vierkantswortel . . . . . . . . . . . . . . . . . . . . . . 425.6 Inversie en deling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435.7 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

6 Veeltermalgoritmes 476.1 Veeltermevaluatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476.2 Inversie van een lineaire veelterm . . . . . . . . . . . . . . . . . . . . 506.3 Algoritme van Euclides . . . . . . . . . . . . . . . . . . . . . . . . . . 516.4 Kwadraat en vierkantswortel . . . . . . . . . . . . . . . . . . . . . . 536.5 Nulpunten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556.6 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

7 Resultaten en toepassingen 577.1 FPGA- en ASIC-synthese . . . . . . . . . . . . . . . . . . . . . . . . 577.2 Schaalbaarheid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607.3 Vergelijking met andere publieke sleutel systemen . . . . . . . . . . . 617.4 Digitale handtekeningen . . . . . . . . . . . . . . . . . . . . . . . . . 62

8 Besluit 65A Patterson-testvectoren 69B Eindig-veldbouwblokken 73

B.1 Vermenigvuldiging . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73B.2 Vermenigvuldiging met x . . . . . . . . . . . . . . . . . . . . . . . . 76B.3 Kwadratering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76B.4 Vierkantswortel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77B.5 Inversie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

C Veeltermbouwblokken 79C.1 Lezen en schrijven van coëfficiënten . . . . . . . . . . . . . . . . . . . 79C.2 FIFO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80C.3 Veelterm-accumulator (POLY_ACCUMUL) . . . . . . . . . . . . . . 81C.4 Programmeerbare veelterm (POLY_BENCH) . . . . . . . . . . . . . 82C.5 Wachtrij van eindig-veldelementen (POLY_QUEUE) . . . . . . . . . 83C.6 Veelterm-conversie (POLY_TURN) . . . . . . . . . . . . . . . . . . 84C.7 Veelterm-vermenigvuldiging (POLY_MUL) . . . . . . . . . . . . . . 84C.8 Vierkantswortel (POLY_SQRT_EO en POLY_SQRT) . . . . . . . 87C.9 Variant op het uitgebreide algoritme van Euclides (POLY_EUCLID) 91C.10 Lineaire-veelterminversie (POLY_INVZA) . . . . . . . . . . . . . . . 97C.11 Algoritme van Chien (POLY_CHIEN) . . . . . . . . . . . . . . . . . 98C.12 Hard gecodeerde veeltermen (REG_G en REG_SQRTZ) . . . . . . 100

D Matrixbouwblokken 101D.1 TRIVIUM_PRNG . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101D.2 MESSAGE_ACCUMUL . . . . . . . . . . . . . . . . . . . . . . . . . 102

Bibliografie 105

iii

Samenvatting

RSA en ECC zijn tot op heden de twee meest gebruikte publieke sleutel algoritmes.Ze zijn gebaseerd op gerelateerde mathematische problemen die voldoende veiligheidbieden in verhouding tot de huidige rekenkracht. De steeds toenemende rekenkrachten een mogelijke doorbraak van kwantum computers in het bijzonder, kunnen deveiligheid echter ondermijnen. De aandacht voor post kwantum veilige algoritmesvanuit de onderzoekswereld gaat dan ook in stijgende lijn. In deze thesis wordt dehardware-efficiëntie van één van de meest veelbelovende algoritmes voor het postkwantum tijdperk onderzocht: McEliece.

In 2009 werd de eerste McEliece hardware-implementatie voorgesteld waarbijencryptie en decryptie op een afzonderlijke Spartan3-AN FPGA gerealiseerd werden.De encryptie blijkt een zeer eenvoudige procedure die geen marge meer biedt voorverdere optimalisatie. In deze thesis wordt de nadruk gelegd op de gecompliceerdedecryptie: hardware-implementaties voor zeer compacte omgevingen zoals RFID-tagslijken onmogelijk op basis van de resultaten van de bestaande FPGA-implementatie.Een XC3S1400AN-5 decryptie-FPGA waarvan 11.218 slices (100%) en 360 kbit aanRAM-geheugen (63%) benut worden, heeft toch nog 1.709.620 klokcycli nodig vooréén enkele decryptie.

Het eigen ontwerp start met een analyse van de zonet besproken implemen-tatie: performantie-pijnpunten en inefficiënties worden opgespoord. Oplossingenworden gezocht op zowel systeem- als algoritmeniveau. Het eindresultaat wordtgesynthetiseerd op dezelfde Spartan3-AN FPGA om aldus de vergelijking te kunnenmaken. Een aanzienlijke verhoging van de efficiëntie wordt bekomen, simultaan voorverschillende aspecten van een digitaal ontwerp. Het totale aantal klokcycli daalt tot94.249, een reductie met circa een factor 18. Het totale aantal slices daalt tot 2979,een reductie met circa een factor 3, 7. De hoeveelheid RAM-geheugen daalt tot 90kbit, een reductie met een factor 4. Verder wordt er flexibiliteit geïntroduceerd metbehulp van hardware-software co-design.

Er wordt tevens een ASIC-synthese van het ontwerp uitgevoerd: deze resul-teert in een Gate Equivalent van 47.762 NAND-poorten (exclusief RAM-geheugen).Lichtgewicht cryptografietoepassingen zoals RFID-tags behoren dus nog niet totde mogelijkheden, maar de kloof lijkt al veel minder groot. De focus bij het eigenontwerp lag echter niet zozeer op deze toepassingen in het bijzonder maar op hetaanpakken van de decryptie-problematieken. Een schaling van het ontwerp evenalsverdere optimalisaties kunnen nog veel betere resultaten opleveren voor dit domein.

iv

Lĳst van figuren en tabellen

Lĳst van figuren

3.1 Parallellisatie van de McEliece-decryptie. . . . . . . . . . . . . . . . . . 213.2 De PicoBlaze 8-bit RISC microcontroller. . . . . . . . . . . . . . . . . . 223.3 Generieke veeltermbouwblok. . . . . . . . . . . . . . . . . . . . . . . . . 223.4 De veeltermbouwblokken voorzien van reconfigureerbare interconnect. . 233.5 Tijdsdiagram van een generieke veeltermbouwblok. . . . . . . . . . . . . 243.6 De PicoBlaze-hardware interface. . . . . . . . . . . . . . . . . . . . . . . 25

4.1 Schematische voorstelling van het TRIVIUM-stroomcijfer. . . . . . . . . 32

5.1 Architectuur van de eindig veld bit-parallelle vermenigvuldiger met d = 11. 415.2 Architectuur van de eindig veld vermenigvuldiging met x. . . . . . . . . 435.3 Architectuur van de eindig veld kwadratuurbouwblok. . . . . . . . . . . 445.4 Architectuur van de eindig veld vierkantswortelbouwblok. . . . . . . . . 44

C.1 Multiplexer-gebaseerde coëfficiënt bewerkingen. . . . . . . . . . . . . . . 79C.2 FIFO-gebaseerde coëfficiënt bewerkingen. . . . . . . . . . . . . . . . . . 80

Lĳst van tabellen

2.1 Reductie van geheugengebruik, met n = 2048 en k = 1751 . . . . . . . . 132.2 Vergelijking van publieke sleutel cryptosystemen met 80-bit veiligheid . 15

3.1 Snelheid van de MicroEliece-implementatie op een XC3S1400AN-5 FPGA. 183.2 Oppervlakte en geheugen van de MicroEliece-implementatie op een

XC3S1400AN-5 FPGA. . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4.1 Hoge-doorvoer FPGA-implementaties van stroom- en blokcijfers en vanhashfuncties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4.2 Lage-doorvoer ASIC-implementaties van stroom- en blokcijfers en vanhashfuncties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.3 Niet-uniforme kansverdeling problematiek van de private sleutel. . . . . 37

5.1 Vergelijking van bit-parallelle vermenigvuldigers. . . . . . . . . . . . . . 42

v

Lĳst van figuren en tabellen

6.1 Exhaustieve veeltermevaluatie. . . . . . . . . . . . . . . . . . . . . . . . 50

7.1 Klokcycli-verdeling voor zowel de eigen implementatie als deMicroEliece-implementatie. . . . . . . . . . . . . . . . . . . . . . . . . . 57

7.2 FPGA- en ASIC-synthese van de McEliece-decryptie. . . . . . . . . . . 587.3 FPGA-implementaties van verschillende publieke sleutel cryptosystemen. 617.4 Vergelijking van McEliece en Niederreiter. . . . . . . . . . . . . . . . . . 63

vi

Lijst van afkortingen ensymbolen

Afkortingen

ASIC Application-Specific Integrated CircuitCCA2 Adaptive Chosen-Ciphertext AttackCISC Complex Instruction Set ComputerESP Equally Spaced PolynomialFF Flip-FlopFIFO First In, First OutFPGA Field-Programmable Gate ArrayFSM Finite State MachineGE Gate EquivalentIV Initial ValueLIFO Last In, First OutLUT Lookup TableMUX MultiplexerNP Nondeterministic Polynomial TimePRNG Pseudo Random Number GeneratorRAM Random-Access MemoryRFID Radio Frequency IdentificationRISC Reduced Instruction Set ComputerRTL Register Transfer LevelVHDL Very High Speed Integrated Circuit Hardware Description Language

vii

Lijst van afkortingen en symbolen

Symbolen

α generatorelement van een eindig veldc codewoord van een lineaire blokcodeC rekenkundige complexiteitd dimensie van het eindig veld GF (2d)e codewoord-foutvector van een lineaire blokcodeg(z) irreduceerbare generatorveelterm van een Goppa-codeG generatormatrix van een lineaire blokcode (McEliece: generatormatrix van

de private Goppa-code)Gi ‘inverse’ generatormatrix van een lineaire blokcodeG publieke generatormatrix van het McEliece-algoritmeGF (n) eindig veld met n elementenf klokfrequentief(x) binaire veelterm die het veld GF (2d) definieertH pariteitscontrolerende matrix van een lineaire blokcodek boodschaplengte van een lineaire blokcode (McEliece: klaartekstlengte)Ix eenheidsmatrix van dimensie xKPRIV private sleutelKPUB publieke sleutelm boodschap van een lineaire blokcode (McEliece: klaartekst)n codewoordlengte van een lineaire blokcode (McEliece: aantal elementen

van een eindig veld evenals de cijfertekstlengte)P permutatiematrixP () probabiliteitπ permutatievectorPRNG() functie die een rij van inverse scramblingmatrix S−1 genereertr ontvangen codewoord (McEliece: cijfertekst)R(z) veelterm van Patterson’s algoritmes foutsyndroomvectorS scramblingmatrixSyn(z) syndroomveelterm van Patterson’s algoritmeσ(z) foutlocatieveelterm van Patterson’s algoritmet foutcorrigerende capaciteit van een lineaire blokcodeT tijdsvertragingT (z) inverse van syndroomveelterm Syn(z) in Patterson’s algoritmeVDD voedingsspanningwt() Hamminggewicht van een binaire matrix of vector

viii

Hoofdstuk 1

Inleiding

“De efficiënte implementatie van een publieke sleutel cryptosysteem”, was de oor-spronkelijke titel van deze thesis. Na een inleiding tot de publieke sleutel cryptografieen de bijhorende problematieken, volgen concrete doelstellingen die deze ietwatalgemene titel vernauwen. Een bespreking van voorgaand werk kadert deze thesis ineen relatief recent onderzoeksdomein. Tenslotte worden het gevolgde ontwerpprocesen een overzicht van de hoofdstukken simultaan behandeld.

1.1 Publieke sleutel cryptografie

Voor de introductie van publieke sleutel cryptografie in 1976 [13], waren symmetrischesleutels de enige beschermer bij de transmissie van vertrouwelijke informatie overeen onveilig communicatiekanaal. Encrypteren van klaartekst door de zender endecrypteren van cijfertekst door de ontvanger gebeurden tot dan enkel met eenzelfdegemeenschappelijke sleutel. Distributie van deze gemeenschappelijke sleutel naaralle partijen is het zwakke punt van symmetrische sleutel algoritmes. Alleen niet-cryptografische methodes boden een oplossing.

De asymmetrische sleutels van publieke sleutel cryptografie verhelpen dit probleem.Elke partij bezit een private en een publieke sleutel waartussen een éénrichtingsrelatiebestaat. De publieke sleutel wordt opgebouwd vanuit de private sleutel, is beschikbaarvoor iedereen en wordt gebruikt voor het encrypteren van klaartekst. Decrypterenvan cijfertekst is enkel mogelijk indien men over de private sleutel beschikt. Het moetonmogelijk zijn om uit een publieke sleutel de corresponderende private sleutel af teleiden in een redelijke rekentijd. De steeds toenemende rekenkracht (zeker indienkwantum computers ooit doorbreken) vormt een grote uitdaging in dit verband.

Publieke sleutel algoritmes zijn over het algemeen veel gecompliceerder danhun symmetrische tegenhangers: implementaties voor toepassingsdomeinen zoalsRFID-tags en draadloze sensornetwerken zijn vaak problematisch. Bemerk dat beidealgoritmeklassen geen concurrenten zijn; ze zijn grotendeels complementair. HetDiffie-Hellman protocol beschrijft hoe een publieke sleutel algoritme een symmetrischesleutel veilig kan verspreiden [13]. Aldus kan een meestal efficiënter symmetrischesleutel algoritme de rol overnemen.

1

1. Inleiding

Publieke sleutel cryptografie opent tevens een waaier van nieuwe toepassingen.Naast de bescherming van vertrouwelijke informatie, vormen digitale handteke-ningen een tweede belangrijk toepassingsgebied; de aangewende algoritmes voorbeide domeinen zijn vaak slechts licht gewijzigde varianten van elkaar. Digitale hand-tekeningen garanderen zowel de authenticiteit als de integriteit van de bijhorendeinformatie. Ze wijzen namelijk uit of ontvangen informatie afkomstig is van eenzekere zender en of er onderweg geen informatie gewijzigd is.

1.2 Thesis-doelstellingen

Het publieke sleutel cryptosysteem is vrij te kiezen, maar moet voldoen aan tenminste één van twee opgelegde voorwaarden. De eerste voorwaarde anticipeert opeen mogelijke doorbraak van kwantum computers in de nabije of verre toekomst.Kwantum computers bevinden zich momenteel nog in een experimentele fase. Eeneventuele doorbraak ondermijnt de veiligheid van de twee meest gebruikte publiekesleutel algoritmes: RSA [47] en ECC [42]. Het breken van RSA is equivalent methet opnieuw factoriseren van een product van twee grote priemgetallen. ECC steuntop het gerelateerde discrete logaritme probleem. Voor goed gekozen parameters,vereist een aanval op deze systemen te veel rekenkracht om praktisch haalbaar zijn.Het tegendeel is waar voor het kwantum computer algoritme van Shor, dat beideproblemen oplost in een polynomiale complexiteit [50].

De tweede voorwaarde doelt op algoritmes die bruikbaar zijn in de lichtgewichtcryptografie en waarvoor dus zeer efficiënte implementaties mogelijk zijn. ZowelRSA als ECC zijn niet geschikt voor zeer compacte omgevingen. Bemerk dat beidevoorwaarden elkaar niet noodzakelijk in de hand werken.

Wegens het gegeven tijdskader, werd de algoritmestudie beperkt tot twee veel-belovende kandidaten voor het post-kwantum tijdperk: McEliece [41] en NTRU[29]. McEliece steunt op een observatie uit de codeertheorie: het decoderen van eenalgemene lineaire foutcorrigerende code is een NP-compleet probleem. NTRU is eenlattice-gebaseerd algoritme; de beste aanvallen herleiden zich tot het oplossen vaneen NP-hard shortest vector of closest vector probleem. De NP-compleetheid enNP-hardheid van deze systemen hebben tot gevolg dat aanvallen met een polynomialetijdscomplexiteit onbestaande zijn.

Van NTRU is reeds aangetoond dat hardware-implementaties voor compacteomgevingen mogelijk zijn [25]. De hardware-efficiëntie van McEliece is tot dusveramper onderzocht. Er wordt uiteindelijk gekozen voor een McEliece-implementatie;een vergelijkende studie later in deze tekst staaft die keuze.

Voor de effectieve implementatie werd er gekozen voor een hardware-softwareco-design. Hardware en software zijn complementair door de essentiële verschillentussen beiden: het beste van twee werelden kan gecombineerd worden. Softwareis sequentieel en heeft flexibiliteit en controle-operaties als voornaamste troeven.Hardware is inherent parallel en blinkt uit in het verwerken van data. De processorwaarvoor er software geschreven wordt, bepaalt de ideale balancering tussen hardwareen software.

2

1.3. Voorgaand werk

1.3 Voorgaand werk

De eerste hardware-implementatie van McEliece (op een FPGA) werd pas recen-telijk voorgesteld in de “MicroEliece: McEliece for Embedded Devices” -paper vande CHES 2009 conferentie [16]. De aandacht voor McEliece-hardware vanuit deonderzoekswereld was gedurende een lange tijd eerder beperkt vanwege de grotesleutels. Het naderende post kwantum tijdperk, sleutelreducerende technieken enCMOS-schaling brachten hierin verandering.

De pas recent ontstane aandacht voor McEliece-hardwaretoepassingen heeft zowelvoor- als nadelen voor het geleverde werk in deze thesis. Enerzijds is er wellichtnog een aanzienlijke marge voor optimalisatie aanwezig, zoals de auteurs van deMicroEliece-paper zelf al aangeven. Naarmate het aantal publicaties rondom deimplementatie van een zeker systeem toeneemt, neemt de efficiëntie logischerwijs toe:auteurs recycleren elkaars vondsten.

Anderzijds zijn er nog geen hardware-implementatiegidsen (die naam waardig)die de meest aangewezen algoritmes voor elke functionaliteit resumeren. Een aantalpapers met software implementaties doen dit wel in beperkte mate, maar hardwarevereist doorgaans een fundamenteel andere aanpak dan software. Algoritme-exploratieper functionaliteit wordt in deze thesis uitgevoerd met behulp van de beschikbarevaklitteratuur. De eigen implementatie wordt regelmatig gecontrasteerd met dezevan de MicroEliece-paper. Ook de finale resultaten worden ermee vergeleken.

1.4 Het ontwerpproces

Een uitgebreide bespreking van het McEliece-algoritme volgt in hoofdstuk 2. Hetontwerpproces start met een software-implementatie van het volledige cryptosys-teem. Deze dient als referentie voor de daaropvolgende hardware-implementatie:testvectoren op maat worden gegenereerd. De gekozen programmeertaal is C/C++,met g++ als compiler. Leesbaarheid, flexibiliteit en correctheid van de code zijn devoornaamste vereisten. Zolang de uitvoeringstijd redelijk blijft, is snelheid hier veelminder belangrijk. Pre- en postcondities van verscheidene methodes worden explicietgecontroleerd door middel van assert-instructies. Wanneer de bijhorende conditiesniet voldaan zijn, stopt de uitvoering van de code. De introductie van fouten wordtgrotendeels vermeden. Het achtereenvolgens encrypteren en decrypteren van eenwillekeurige klaartekst vormt de finale test. De parameters van het algoritme wordenniet hard gecodeerd met een instelbaar veiligheidsniveau tot gevolg. Een bijkomendvoordeel is dat men de parameters kan afstemmen op bestaande testvectoren. Ookde herbruikbaarheid van code neemt toe. De software-implementatie wordt verderniet besproken in deze tekst.

Het digitale ontwerp start met het hoogste digitale abstractieniveau: hoofdstuk 3contrasteert het eigen ontwerp met de reeds bestaande hardware-implementatie. Deafweging tussen hardware en software wordt er eveneens uitvoerig besproken. Dedaaropvolgende hoofdstukken zijn ingedeeld per rekenkundig domein. De sleutels vanhet McEliece publieke sleutel systeem resulteren grotendeels uit binaire matrix- en

3

1. Inleiding

vectorbewerkingen en worden besproken in hoofdstuk 4. De bewerkingen met eindig-veldelementen en met veeltermen over het betreffende eindig veld zijn bepalend voorde decryptie; ze worden besproken in hoofdstuk 5 en 6 respectievelijk. De encryptieis een uiterst eenvoudige procedure waarvoor geen apart hoofdstuk voorzien wordt.

De gekozen hardware-beschrijvingstaal is GEZEL [27], met de mogelijkheid tothardware-software co-simulatie als voornaamste troef. Instructiesets van StrongARM-, MicroBlaze-, PicoBlaze- en 8051-processoren worden ondersteund. GEZEL-codekan vervolgens geconverteerd naar VHDL met behulp van een tool. De bekomenVHDL-code wordt vertaald naar een FPGA-implementatie met behulp van de XilinxISE Design Suite. Het syntheseprogramma levert een schat aan informatie over hetdigitale ontwerp: een optimalisatielus met de GEZEL code komt tot stand. Wegenshet beperkte tijdskader, wordt er enkel een stelselmatige verkorting van het kritischepad aangevat.

Met de deels geoptimaliseerde code wordt tevens een CMOS-synthese gerealiseerdmet behulp van Synopsys Design Vision. Hierbij wordt een 0, 13µm UMC standardcell bibliotheek gebruikt. De resultaten van zowel de FPGA- als de CMOS- syntheseworden besproken in hoofdstuk 7. Ook de bijhorende verbeteringen worden ervoorgesteld, evenals de mogelijke toepassingen van het ontwerp. Een finaal besluit inhoofdstuk 8 vat alles nog eens samen.

4

Hoofdstuk 2

Het McEliece-algoritme

Het McEliece publieke sleutel cryptosysteem [41] is gebaseerd op foutcorrigerendecodes. De bewerkingen zijn onder te verdelen in twee rekenkundige domeinen.Enerzijds zijn er de binaire matrices en vectoren die voortvloeien uit het gebruikfoutcorrigerende codes. Anderzijds zijn er de veeltermen over een eindig veld dieresulteren uit het gebruik van Goppa-codes in het bijzonder.

Eerst worden de vereiste basisconcepten van eindig veld rekenkunde en van fout-corrigerende codes toegelicht. Pas daarna kan het McEliece-algoritme zelf bespokenworden; dit gebeurt volgens het referentiekader van een publieke sleutel cryptosys-teem. Vervolgens worden veiligheid en geheugenreductie, twee sterk gerelateerdeonderwerpen, besproken. Tenslotte volgt er een vergelijking van McEliece met anderepublieke sleutel cryptosystemen; de keuze voor McEliece wordt in diezelfde sectiegestaafd.

2.1 Eindig veld rekenkundeWe noteren een eindig veld met n elementen als GF (n). Het aantal elementen vaneen eindig veld is steeds een positieve macht van een priemgetal p, de zogenaamdekarakteristiek van het veld [39]:

n = pd met d ≥ 1.

Voor het McEliece-algoritme is enkel de subklasse met karakteristiek twee van belang.De elementen van een eindig veld GF (2d) kunnen dan worden voorgesteld als eenbinaire veelterm met variabele x:

a(x) = ad−1xd−1 + ad−2x

d−2 + . . .+ a1x+ a0 met ai ∈ GF (2).

Een irreduceerbare veelterm f(x) van graad d over GF (2) definieert het veld.Een eindig veld is uitgerust met twee samenstellingswetten: de optelling en de

vermenigvuldiging. Bewerkingen zoals inversie, deling en exponentiëring zijn allemaalte herleiden tot een (meervoudige) vermenigvuldiging. De kleine stelling van Fermatspeelt hierin een belangrijke rol:

an = a met a ∈ GF (n).

5

2. Het McEliece-algoritme

Alle elementen van een eindig veld (uitgezonderd het nulelement) kan men schrijvenals een macht van een generatorelement α:

a = αi met i ∈ [0, n− 2].

Voor het McEliece-algoritme zijn eveneens veeltermen over een eindig veld GF (2d)van belang. De veeltermbewerkingen worden gedefinieerd door een irreduceerbareveelterm g(z) van graad t:

g(z) = gtzt + gt−1z

t−1 + . . .+ g1z + g0. met gi ∈ GF (2d).

Hoewel er een nieuw eindig veld met 2td elementen ontstaat, gebruiken we de term‘eindig veld’ enkel voor de elementen van GF (2d) om verwarring te vermijden. Wegebruiken eveneens een andere veeltermvariabele, namelijk z. Algemene conceptenzoals de kleine stelling van Fermat gelden opnieuw: voor een willekeurige veeltermp(z) geldt dat

p2td(z) = p(z) mod g(z)

2.2 Foutcorrigerende codesFoutcorrigerende codes zijn een begrip uit de codeertheorie [53]. Bij transmissie vandigitale data over een ruizig communicatiekanaal, kunnen er bitfouten ontstaan. Doorhet inbrengen van redundantie bij de transmissie, is de ontvanger toch in staat omde oorspronkelijke boodschap te reconstrueren. De manier waarop deze redundantiewordt ingebouwd, is afhankelijk van de betreffende foutcorrigerende code. Alvorensde Goppa-codes van het McEliece algoritme te bespreken, worden de concepten vanmeer algemene lineaire blokcodes besproken.

2.2.1 Lineaire blokcodes

Lineaire, binaire [n, k] blokcodes vormen een belangrijke klasse foutcorrigerende codes.De zender encodeert een boodschap van k bits om aldus een codewoord van n bits tebekomen. Het aantal redundante bits bedraagt n− k. De foutcorrigerende capaciteitt van een code bepaalt het maximum aantal bitfouten in de datatransmissie opdatreconstructie mogelijk blijft.

Alles wordt mathematisch geformuleerd met binaire matrices en vectoren. Bood-schap m en codewoord c zijn rijvectoren met lengtes k en n respectievelijk. Beschouween k × n generatormatrix G met rang k waarvan de rijen een basis vormen van dek-dimensionale code. Elk codewoord kan dus herschreven worden als een lineairecombinatie van de rijen van G. Het encoderen van een boodschap vertaalt zich naareen vector-matrix vermenigvuldiging: c = mG.

Systematische blokcodes vormen een interessante subklasse van de algemenelineaire blokcodes. De generatormatrix heeft dan de vorm G = [Ik Q], met Ikde k-dimensionale eenheidsmatrix en Q een k × (n − k) coëfficiëntenmatrix. Eencodewoord begint nu met de k boodschapsbits, gevolgd door n − k pariteitsbits.Een zekere generatormatrix kan altijd in systematische vorm gebracht worden door

6

2.2. Foutcorrigerende codes

middel van elementaire rij-operaties. Een Gauss-Jordaneliminatie die een willekeurigematrix in rij-gereduceerde echelonvorm brengt, leent zich hiertoe. [38].

Men kan elke ontvangen vector (dit is elke vector van lengte n) ontbinden alsr = c+ e, met c het dichtstbijzijnde codewoord en e de corresponderende foutvector.Het Hamming gewicht wt(e), dit is het aantal ‘1’-elementen in de foutvector, maghoogstens t bedragen indien men nog wil kunnen decoderen. Het decoderen vaneen ontvangen vector r komt neer op het vinden van het meest nabijgelegen geldigcodewoord c (of ook de corresponderende foutvector e). Een exhaustieve zoektochtis hiervoor uitermate inefficiënt.

Syndroomdecodering vormt een beter alternatief. Beschouw een (n − k) × npariteitscontrolerende matrix H die voldoet aan de eigenschap cHT = 0, met c eenwillekeurig codewoord. Een generatormatrix en een pariteitscontrolerende matrixzijn bijgevolg een equivalente voorstelling van een code:

cHT = mGHT = 0⇔ GHT = 0.

Voor een systematische generatormatrix bekomt men H = [QT In−k]. Ontvangenvectoren waarvoor de 1 × (n − k) syndroomvector s = rHT een nulvector is, zijncorrect. Men kan bewijzen dat vectoren met dezelfde syndroomvector s dezelfdefoutvector e hebben ten opzicht van hun respectievelijke dichtstbijzijnde codewoorden.Een tabel met alle mogelijke syndroomvectoren en hun corresponderende foutvectorwordt opgesteld. De verzameling van ontvangen vectoren wordt eerst onderverdeeldin disjuncte deelverzamelingen (zogenaamde cosets) waarvan de elementen dezelfdesyndroomvector s = rHT hebben. De vector met het laagste Hamming gewicht (decosetleider) is de gemeenschappelijke foutvector e voor alle elementen van de coset.

Eenmaal het meest nabijgelegen codewoord c gevonden is, bekomt men deoorspronkelijke boodschap m door het overgedetermineerde stelsel c = mG op telossen. Bij een veelvuldige decodering loont het om de n× k matrix Gi te zoekenwaarvoor geldt dat GGi = Ik. Een vector-matrix vermenigvuldiging resulteert in deoorspronkelijke boodschap: m = cGi.

Voor grote codes is syndroomdecodering jammer genoeg niet efficiënt. Het vindenvan het meest nabijgelegen geldig codewoord voor een algemene code is een NP-compleet probleem. Uit deze observatie zijn de cryptografische toepassingen ontstaan.Bepaalde klassen codes (Hamming-codes, Goppa-codes, . . . ) hebben wel een efficiëntdecoderingsalgoritme met een polynomiale complexiteit. We beperken ons tot deGoppa-codes vermits deze aan de basis liggen van McEliece.

2.2.2 Goppa-codes

Lineaire [n, k] Goppa-codes worden gebruikt in het McEliece-algoritme. Beschouween eindig veld GF (2d) met n = 2d elementen: a0, a1, . . . , an−1. De volgorde van deelementen ai mag arbitrair gekozen worden. Ze kan bijvoorbeeld worden vastgelegddoor een teller (ai = i) of door een generatorelement (ai = αi).

Een monische irreduceerbare veelterm g(z) van graad t over het eindig veldGF (2d), met 2 ≤ t ≤ n−1

d , definieert de veeltermbewerkingen:

g(z) = zt + gt−1zt−1 + . . .+ g1z + g0. met gi ∈ GF (2d).

7


Elk veelvoud ag(z) met a 6= 0, is opnieuw een irreduceerbare veelterm die hetzelfdeveld van veeltermbewerkingen definieert. De eis voor een monische g(z) mag alseen standaardisatie beschouwd worden en verandert niets aan de code op zich. Deveeltermbewerkingen worden er bovendien eenvoudiger op. Een boodschap heeftlengte k = n− td. Een codewoord c = [c0 c1 . . . cn−1] maakt deel uit van de codeindien

n−1∑i=0

ciz + ai

= 0 mod g(z).

Een (n− k)× n pariteitscontrolerende matrix is als volgt:

H =

1/g(a0) 1/g(a1) . . . 1/g(an−1)a0/g(a0) a1/g(a1) . . . an−1/g(an−1)

...... . . . ...

at−10 /g(a0) at−1

1 /g(a1) . . . at−1n−1/g(an−1)

De elementen van deze matrix stellen kolomvectoren met lengte d voor.

Het algoritme van Patterson [44] zorgt voor een efficiënte decodering. Beschouwhet ontvangen codewoord r′ = [r0 r1 . . . rn−1]. De syndroomveelterm is als volgt:

Syn(z) =n−1∑i=0

riz + ai

mod g(z).

Indien Syn(z) = 0, is het ontvangen codewoord correct. In het andere geval startmen een procedure van veeltermbewerkingen die tot de foutvector e leidt. Eerstberekent men de syndroomveelterm-inverse

T (z) = Syn−1(z) mod g(z).

Vervolgens berekent men de vierkantswortel

R(z) =√T (z) + z mod g(z).

Bereken dan a(z) en b(z), met maximale graad bt/2c en b(t− 1)/2c respectievelijk,waarvoor geldt dat

a(z) = b(z)R(z) mod g(z).

Bemerk dat a(z) en b(z) maar tot op een constante factor na bepaald zijn. Berekenvervolgens de foutlocatieveelterm

σ(z) = a2(z) + zb2(z),

met maximale graad t, zonder deze te reduceren met g(z). Splits σ(z) in lineairefactoren om aldus de nulpunten te bekomen. Ieder van de hoogstens t nulpunten aigeeft een bitfout weer in de vector r′ op positie i. Noem het gecorrigeerde codewoorden dus de gewenste resultante c′. Testvectoren voor Patterson’s algoritme wordengegeven in appendix A.

8

2.3. McEliece als publieke sleutel cryptosysteem

2.3 McEliece als publieke sleutel cryptosysteem

De bespreking van McEliece is opgedeeld volgens de drie fasen van een publiekesleutel cryptosysteem: sleutelgeneratie, encryptie en decryptie.

2.3.1 Sleutelgeneratie

Beschouw een willekeurige [n, k] Goppa-code met foutcorrigerende capaciteit t. Eenk × n generatormatrix G representeert deze code. Decoderen kan efficiënt metbehulp van Patterson’s algoritme. Een lineaire transformatie van G op basis vaneen willekeurige k × k niet-singuliere scramblingmatrix S en een random n × npermutatiematrix P resulteert in een tweede code: het matrixproduct G = SGPdefinieert een tweede generatormatrix. De corresponderende [n, k] blokcode heefteveneens foutcorrigerende capaciteit t, maar heeft geen efficiënt decoderingsalgoritmewegens de algemene structuur van G.

De algemene generatormatrix G is de publieke sleutel. De private sleutel bestaatenerzijds uit de Goppa-generatormatrix G en anderzijds uit de transformatiema-trices S en P . De private sleutel wordt doorgaans herleid naar een vorm die dedecryptie ten goede komt. De sleutelgeneratie is immers niet tijdskritisch in demeeste praktische toepassingen. Bovendien worden de sleutels voor een groot aantalhardware-toepassingen vooraf berekend.

De parameterverzameling {n, k, t} van de blokcodes is meteen ook deze van hetglobale algoritme. Boodschappen van k bits worden versleuteld tot n bits en viceversa. De beschreven asymmetrie garandeert de veiligheid van het cryptosysteem opvoorwaarde dat de code voldoende ‘groot’ is: de parameters {n = 2048, k = 1751,t = 27} bijvoorbeeld, corresponderen qua veiligheid met symmetrische sleutelsvan 80 bit [3]. Het voornaamste nadeel van McEliece zijn dan ook de zeer grotesleutelmatrices.

2.3.2 Encryptie

Confidentiële informatie wordt opgedeeld in blokken van k bits en versleuteld intwee stappen (zie algoritme 2.1). Encodering van een boodschapvector m met depublieke blokcode in stap 1 resulteert in een correct codewoord c. Introductie van twillekeurige bitfouten in stap 2 resulteert in het foutieve codewoord r. Correctie vanr op basis van de publieke blokcode is een NP-compleet probleem. Bemerk dat deencryptie-procedure zeer eenvoudig is in vergelijking met vele andere publieke sleutelalgoritmes en dus geschikt is voor lage kost toepassingen.

Algoritme 2.1 McEliece-encryptieIn: klaartekst m ∈ {0, 1}1×kIn: publieke generatormatrix G ∈ {0, 1}k×nUit: cijfertekst r ∈ {0, 1}1×n

1: c = mG {boodschap naar codewoord}2: r = c+ e, met wt(e) = t {introductie t bitfouten}

9


2.3.3 Decryptie

Decryptie van cijfertekst is enkel mogelijk via de private Goppa-code die een efficiëntedecodering mogelijk maakt. Vermits encrypteren met de getransformeerde codegebeurt, wordt een inverse transformatie verweven doorheen het decryptie-proces(zie algoritme 2.2). In stap 1 neutraliseert men de permutatiematrix. Vervolgensproduceert Patterson’s algoritme (stappen 2-8) een correct codewoord c′. Een vector-matrix vermenigvuldiging in stap 9 resulteert in de corresponderende boodschapm′. Neutralisatie van de scramblingmatrix in stap 10 onthult de oorspronkelijkeklaartekst-boodschap m. De meest geschikte vorm van de private sleutel voor eensnelle decryptie is als volgt: {P−1, g(z), Gi, S−1}. Bemerk dat g(z) en Gi theoretischgezien equivalent zijn.

Algoritme 2.2 McEliece-decryptieIn: cijfertekst r ∈ {0, 1}1×nIn: inverse permutatiematrix P−1 ∈ {0, 1}n×nIn: Goppa generatorveelterm g(z) van graad t over het veld GF (n)In: Goppa codewoord-naar-boodschap matrix Gi ∈ {0, 1}n×kIn: inverse scramblingmatrix S−1 ∈ {0, 1}k×kUit: klaartekst m ∈ {0, 1}1×k

1: r′ = rP−1 {neutralisatie permutatiematrix}2: Syn(z) =

∑ri/(z + ai) mod g(z) {syndroomveelterm}

3: T (z) = Syn(z)−1 mod g(z) {syndroomveelterm-inversie}4: R(z) =

√T (z) + z mod g(z) {vierkantswortel}

5: a(z) = b(z)R(z) mod g(z) {oplossen veeltermvergelijking}6: σ(z) = a2(z) + zb2(z) {foutlocatieveelterm}7: Nulpunten σ(z) {foutvector e}8: c′ ← r′ + e {correctie t bitfouten}9: m′ = c′Gi {boodschapsextractie}

10: m = m′S−1 {neutralisatie scramblingmatrix}

2.4 Veiligheid

Veelvuldig onderzoek heeft nog geen (kwantum computer) algoritmes opgeleverddie McEliece breken in een sub-exponentiële tijdscomplexiteit. De meest effectievealgoritmes zijn allemaal varianten van het ‘information-set decoding’ algoritme. Ver-volgens wordt de Adaptive Chosen-Ciphertext Attack (CCA2) -veiligheid van McEliecebesproken. Enkel de basisconcepten worden hier toegelicht; een uitgebreid overzichtvan de veiligheid van McEliece kan men vinden in bijvoorbeeld [17]. Tenslotte wordthet onderzoeksdomein gekaderd waarin men op zoek gaat naar sleutelreducerendevarianten van McEliece.

10

2.4. Veiligheid

2.4.1 information-set decoding

Het information-set decoding algoritme decodeert een algemene [n, k] blokcode. Deefficiëntie ligt hoger dan bij de eerder besproken syndroomdecodering. Uit eencijfertekst r = mG + e wil men klaartekst m reconstrueren enkel op basis van depublieke sleutel G. Men weet dat foutvector e Hamming gewicht t heeft. Beschouwde verzameling kolomindices {0, 1, . . . , n− 1} van G, r en e. Een iteratieve procedurekiest een willekeurige deelverzameling I van k elementen. De volgende relatie isgeldig:

mGI = rI + eI .

Het exacte Hamminggewicht van foutvector eI is niet gekend, maar bedraagt hoog-stens t. Men veronderstelt dat eI een nulvector is, hoewel de kans hiertoe verwaar-loosbaar is voor goed gekozen veiligheidsparameters. De reconstructie herleidt zichdan tot het oplossen van een overgedetermineerd stelsel met resultante m2 (indienmogelijk). De voorwaarde voor een succesvolle decodering is als volgt:

wt(rI +m2GI) = t.

In de praktijk veronderstelt men dat foutvector eI een zeer laag Hamminggewichtheeft. Voor alle mogelijke combinaties van eI lost men opnieuw een stelsel op en mencontroleert of de resultante voldoet aan bovenstaande vergelijking. Hoe hoger menhet Hamminggewicht van foutvector kiest, hoe groter de kans dat dit ook werkelijkzo is, maar ook hoe meer mogelijke combinaties voor eI men moet uitproberen.

Talrijke gecompliceerde varianten worden beschreven in de vaklitteratuur. Demeest effectieve is ongetwijfeld deze van Bernstein et al. [3]. Een succesvolleaanval in deze publicatie demonstreert dat de oorspronkelijk voorgestelde McEliece-parameterwaarden n = 1024, k = 524 en t = 50 onveilig zijn. Alternatieve pa-rameterwaarden worden voorgesteld, ingedeeld volgens het gewenste niveau vanveiligheid.

2.4.2 CCA2-veiligheid

Publieke sleutel algoritmes zijn CCA2-veilig indien ze resistent zijn tegen een eerderhypothetische aanval. De aanvaller moet namelijk een willkeurige cijfertekst ontcijfe-ren en heeft hiervoor een quasi ongelimiteerde decryptie-procedure ter beschikking:alle cijferteksten naar keuze, behalve deze die men effectief wil ontcijferen, kunnenzomaar gedecrypteerd worden. CCA2-veiligheid moet beschouwd worden als eentheoretisch model waardoor de mogelijkheid tot vele meer realistische aanvallenuitgesloten wordt.

Het oorspronkelijke McEliece algoritme is niet CCA2-veilig: een eenvoudig voor-beeld dient ter illustratie. Beschouw de encryptie van twee klaarteksten m1 en m2waarvan een aanvaller weet hoe ze gerelateerd zijn: m1 +m2 is gekend. Vermits

c1 + c2 = (m1 +m2)G+ (e1 + e2),

11


kent de aanvaller eveneens de relatie tussen de corresponderende foutvectoren. Eenmeervoudige encryptie van dezelfde klaartekst is een bijzonder geval van het voor-gaande voorbeeld.

Verscheidene technieken verhelpen dit probleem; ze worden beschreven in devaklitteratuur. Het achterliggende principe is altijd hetzelfde: er vindt een bijkomendescrambling-operatie op de klaartekstbits plaats. Het gebruik van een systematischepublieke generatormatrix G wordt eveneens toelaatbaar.

2.4.3 Sleutelreducerende varianten van McEliece

Varianten van McEliece die de private en publieke sleutels reduceren werden reedsvoorgesteld door verscheidene auteurs. De Goppa-codes worden doorgaans vervangendoor een andere foutcorrigerende code. Al deze varianten zijn tot op heden ofwelgebroken (bijvoorbeeld [54]), ofwel pas zeer recentelijk voorgesteld en bijgevolg nogonvoldoende onderzocht. Het zoeken naar dergelijke varianten die hopelijk wel veiligblijken, is momenteel een zeer actief onderzoeksdomein.

2.5 Reductie van geheugengebruik

Het geheugengebruik van de publieke en private sleutelmatrices is het zwakke punt vanMcEliece. Elk van deze matrices heeft echter een corresponderende reductietechniekdie geen afbreuk doet aan de veiligheid, zoals beschreven in de MicroEliece-paper[16]. De technieken worden hier nog eens hernomen; tabel 2.1 geeft een overzichtvan de reductie voor de eerder vermelde parameterwaarden.

De Goppa-generatormatrix G hoeft slechts éénmaal expliciet berekend te worden(bij de aanmaak van de publieke sleutel). Het algoritme van Patterson gebruikt deequivalente maar veel compactere generatorveelterm g(z).

Slechts één van beide generatormatrices kan in systematische vorm gebrachtworden. Een simultaan systematische G = [Ik Q] en G = SGP = [Ik Q] resulteertnamelijk in een onveilige scramblingmatrix S = Ik. De opslag of transmissie vaneen eenheidsmatrix is niet aangewezen: een reductie van G of G tot k(n− k) bitskan bekomen worden. De private Goppa-generatormatrix G te verkiezen boven Gomwille van drie redenen. Een systematische G is enkel toegelaten bij de CCA2-veilige varianten van McEliece. Verder wordt de decryptie-procedure versneld doorhet wegvallen van de vector-matrix vermenigvuldiging m′ = c′Gi: de eerste k bits vanhet gecorrigeerde codewoord c′ zijn dan identiek met de boodschap m′. De opslagvan de private matrix Gi is bijgevolg ook niet meer vereist. Een bijkomend voordeeldat niet wordt uitgebuit in de MicroEliece-implementatie is de mogelijkheid tot eenparallelle decryptie-procedure (zie sectie 3.2).

De inverse kolom-permutatiematrix P−1 heeft een spaarse structuur: elke rijof kolom bevat exact één ‘1’-bit. Dezelfde informatie kan vervat worden in eenkolomindices-vector van lengte n. Het aantal representatiebits per index bedraagtlog2(n) = d. Dezelfde vector is eveneens een representatie van kolom-permutatiematrixP .

12

2.6. Vergelijking met andere publieke sleutel algoritmes

Inverse scramblingmatrix S−1 heeft een volle structuur: elk element heeft eengelijke kans om ‘0’ of ‘1’ te zijn. Het vullen van S−1 is mogelijk met een cryptografischePseudo Random Number Generator (PRNG). Na initialisatie met een zogenaamdeseed-waarde, zal een dergelijke PRNG altijd dezelfde sequentie van bits produceren.De seed-waarde (typisch enkele tientallen bytes) bevat bijgevolg dezelfde informatieals de volledige matrix. Een PRNG is hierin fundamenteel verschillend van een wareRandom Number Generator.

Fase Geheugen voor (bits) Geheugen na (bits) ReductietechniekSleutelgeneratieG k × n 3.586.048 k × (n− k) 520.047 systematische vormP n× n 4.194.304 log2(n)n 22.528 spaarse matrixDecryptieGi n× k 3.586.048 0 systematische GP−1 n× n 4.194.304 log2(n)n 22.528 spaarse matrixS−1 k × k 3.066.001 seed ≈ 100 PRNG

Tabel 2.1: Reductie van geheugengebruik, met n = 2048 en k = 1751

2.6 Vergelijking met andere publieke sleutel algoritmes

McEliece wordt vergeleken met drie andere publieke sleutel cryptosystemen. Demomenteel meest gebruikte cryptosystemen, RSA [47] en ECC [42], dienen alsreferentie beschouwd te worden. Vooral de vergelijking met NTRU [29], een tweedepost kwantum cryptosysteem, is belangrijk. Deze vormt namelijk de argumentatiewaarom er voor McEliece gekozen is.

2.6.1 Theoretische vergelijking

Tabel 2.2 vergelijkt de vier cryptosystemen voor eenzelfde veiligheidsniveau van80 bit. Bij ECC beschouwen we zowel een veld gedefinieerd door een priemgetalals door een binaire veelterm; de parameters per veiligheidsniveau vinden we in[7]. Bemerk dat ECC in tegenstelling tot de andere algoritmes geen encryptie- ofdecryptieprocedure heeft. Er is anderzijds wel een Diffie-Hellman protocol [13] datbeschrijft hoe twee partijen een gemeenschappelijke symmetrische sleutel kunnenberekenen. Hiervoor hoeft er enkel publieke informatie uitgewisseld te worden.

De grote sleutelmatrices vormen het zwakke punt van McEliece, ondanks dereductietechnieken beschreven in sectie 2.5. Dit is meteen ook de hoofdreden waarombijvoorbeeld RSA (ontstaan in dezelfde historische periode) veel populairder isgeworden. Met de steeds toenemende rekenkracht is de aandacht voor McEliecevanuit de onderzoekswereld wel in stijgende lijn blijven gaan.

De ratio van cijfertekstlengte en klaartekstlengte (de boodschapsexpansie) is lagerdan bij concurrent NTRU. Een schema dat deze ratio nog verder verlaagt wordtbesproken in [5]: de posities van de bitfouten in een cijfertekst worden aangewend als

13


extra informatiedrager. De veiligheid van het McEliece-algoritme (met Goppa-codes)heeft nooit ter discussie gestaan. Enkel de oorspronkelijke parameterwaarden uit1978 zijn gewijzigd vermits deze niet gebaseerd waren op de meer recente aanvallen.Van NTRU daarentegen zijn er wel al verscheidene versies gebroken. Beide algoritmesbieden de mogelijkheid tot een snelle encryptie en decryptie.

Er zijn nog enkele niet-wetenschappelijke argumenten die de keuze voor McEliecemotiveren. Er zijn ten eerste geen auteursrechten vanuit een commerciële organisatievan toepassing. Verder is er ook nog maar één bestaande hardware-implementatiedie nog een ruime marge biedt voor optimalisatie, zoals eerder vermeld in sectie1.3. Daarnaast is er de toegenomen interesse vanuit de onderzoekswereld. Tenslottespelen ook didactische aspecten een rol: een McEliece-implementatie vereist eenverscheidenheid aan technieken uit zowel de eindig-veldrekenkunde als de lineairealgebra. De vereist functionaliteiten voor NTRU zijn eerder beperkt (wat anderzijdswel de compactheid ten goede komt)

2.6.2 Bestaande implementaties

Het eBACS project [15] vergelijkt software-implementaties van RSA, McEliece enNTRU. Het platform is telkens een general purpose processor van AMD of Intel.Het aantal klokcycli voor de sleutelgeneratie, de encryptie en de decryptie wordengetabelleerd. McEliece en NTRU blijken zeer concurrentieel qua snelheid voor dedrie fasen van een publieke sleutel cryptosysteem. Beide algoritmes overtreffen RSAruimschoots. De vergelijking is echter te onvolledig voor verregaande conclusies:enkel het aspect snelheid krijgt aandacht.

In [16] wordt de snelheid vergeleken voor zowel 8-bit processor als FPGA hardware-implementaties. De verschillen tussen RSA, McEliece en ECC zijn beperkt voor de8-bit processoren. Gegevens voor NTRU zijn niet beschikbaar. De NTRU FPGA-implementatie is drie ordegroottes sneller dan McEliece en ECC, die op hun beurteen ordegrootte sneller zijn dan RSA. De vergelijking is opnieuw te onvolledig voorverregaande conclusies.

2.7 BesluitHet McEliece publieke sleutel algoritme werd besproken in een brede context. Depost kwantum veiligheid staat niet ter discussie, waarmee de eerste thesis-voorwaardevoldaan is. Het grote nadeel van McEliece blijkt het grote geheugengebruik vanwegede publieke en private sleutels, zelfs met de aangehaalde reductietechnieken. Verschei-dene implementaties in hoog-niveau programmeertalen werden reeds gemaakt. Deenige bestaande hardware-implementatie (FPGA) biedt echter nog veel ruimte om deefficiëntie te optimaliseren. We onderzoeken in hoeverre de tweede thesis-voorwaardein verband met compacte omgevingen haalbaar is. Een mapping van McEliece naarCMOS-technologie is tot dusver onbestaande. Het ontwerp start met een hoog-niveaustudie in het volgende hoofdstuk.

14

2.7. BesluitRSA

ECC

McE

liece

NTRUEn

cryp

thistoriek

1977

1985

1978

1998

rechten

publiekdo

mein

publiekdo

mein

1pu

bliekdo

mein

c ©Se

curit

yInno

vatio

npa

rameters

leng

teN

=10

24GF

(p):

priemgetalp

=216

0−...

code

woo

rdbitsn

=20

48orde

ringN

=25

1GF

(2m

):expo

nentm

=16

3bo

odscha

pbitsk

=17

51priemgetalq

=19

7GF

(2m

):irr

ed.f

(x)=

x16

3+...

bitfou

tent

=27

priemgetalp

=2

curvepa

rametera∈GF

(.)cu

rvepa

rameterb∈GF

(.)gene

ratorpu

ntGx,y∈GF

(.)cu

rveorde

n≈

168b.

cofactorh≈

8b.

klaa

rtekst

1024

b./

1751

b.25

1b.

cijfe

rtekst

1024

b./

2048

b.20

08b.

KPRIV

O(N

)O

(p)ofO

(2m

)O

(n2 )

O(N

)mod

ulusn(102

4b.)

scalard(≤

168b.)

gene

ratorg(z

)(297

b.)

veelterm

f(≈

4kb

.)expo

nentd(≤

1024

b.)

scramblingS

(80b.)

veelterm

f p(≈

4kb

.)pe

rmutatieP

(≈23

kb.)

KPUB

O(N

)O

(p)ofO

(2m

)O

(n2 )

O(N

)mod

ulusn(102

4b.)

curvepu

ntQ

(≈32

0b.)

gene

ratorG

(≈35

86kb

.)veelterm

h(≈

16kb

.)expo

nente(≤

1024

b.)

encryp

tieO

(N3 )

niet

vantoep

assin

gO

(n2 )

O(N

2 )de

cryp

tieO

(N3 )

niet

vantoep

assin

gO

(n2 )

O(N

2 )veiligh

eid

niet

post

kwan

tum

niet

post

kwan

tum

post

kwan

tum

post

kwan

tum

gebroken

versies

Tab

el2.

2:Ve

rgelijk

ingvanpu

blieke

sleutel

cryp

tosystem

enmet

80-bitveiligh

eid

a nog

aanw

ezig

epa

tent

enzi

jnte

omze

ilen

15

Hoofdstuk 3

Ontwerp op systeemniveau

Het ontwerpproces start met het hoogste digitale abstractieniveau. Deze fase isuitermate belangrijk vermits beslissingen op systeemniveau vaak doorslaggevend zijnvoor de totale performantie. Bovendien wordt er een referentiekader vastgelegd voorde onderliggende abstractieniveaus.

Eerst wordt de performantie van de bestaande MicroEliece [16] FPGA-implementatiebestudeerd. De pijnpunten die aanleiding geven tot cruciale wijzigingen in de eigenimplementatie, worden ingeleid. De aanpak voor elk van deze pijnpunten wordtuitvoerig besproken in latere hoofdstukken. Eén van de pijnpunten wordt aangepaktop systeemniveau en wordt bijgevolg in dit hoofdstuk behandeld. Het ontwerp is eenhardware-software co-design; de concrete invulling van dit concept wordt uitgebreidtoegelicht.

3.1 MicroEliece FPGA-implementatie

De gekozen parameters n = 2048, k = 1751 en t = 27 corresponderen met een 80-bitveiligheid. De encryptie en decryptie worden elk op een afzonderlijke Spartan-3ANFPGA geïmplementeerd; de sleutels worden vooraf berekend. Tabel 3.1 resumeertde snelheid van het ontwerp: enerzijds het aantal klokcycli per algoritmestap enanderzijds de maximale klokfrequentie op het gebruikte platform. Tabel 3.2 resumeertde compactheid van het ontwerp, zowel qua logica als qua geheugen. Gegevens perbouwblok zijn helaas niet beschikbaar. Performantie van encryptie en decryptieworden besproken aan de hand van de getabelleerde waarden. De aanpak van deperformantie-pijnpunten in de eigen implementatie wordt ingeleid.

3.1.1 Encryptie

De McEliece-encryptie wordt gekenmerkt door eenvoud. Zowel de snelheid als decompactheid worden bepaald door één enkele vector-matrix vermenigvuldiging, eenbewerking die zich bovendien uitstekend leent tot een parallelle uitvoering. In ruilvoor extra logica, kan men de encryptie arbitrair snel maken. De exacte afwegingtussen snelheid en oppervlakte is volledig afhankelijk van de applicatie. De publieke

17

3. Ontwerp op systeemniveau

Stap Klokcycli

Encryptie(150Mhz)

Boodschap naar codewoord c = mG 161.480Introductie t bitfouten r = c+ e 398Totaal 161.878

Decryptie(85Mhz)

{Neutralisatie permutatieLineaire-veelterminversie

r′ = rP−1360.184

Syn(z) =∑ri/(z + ai)

Syndroomveelterm-inversie T (z) = Syn(z)−1 625Vierkantswortel R(z) =

√T (z) + z 487

Oplossen veeltermvergelijking a(z) = b(z)R(z) 312Nulpunten foutlocatieveelterm σ(z) = 0 312.328Neutralisatie scramblingmatrix m = m′S−1 1.035.684Totaal 1.709.620

Tabel 3.1: Snelheid van de MicroEliece-implementatie op een XC3S1400AN-5FPGA.

XC3S1400AN-5 Encryptie-FPGA Decryptie-FPGASlices 11264 668 6% 11218 100%LUT-slices 22528 1044 5% 22034 98%FF-slices 22528 804 4% 8977 40%18 kbit RAM-blokken 32 (576 kbit) 3 (54 kbit) 9% 20 (360 kbit) 63%extern RAM-geheugen ≥ 3586 kbit

Tabel 3.2: Oppervlakte en geheugen van de MicroEliece-implementatie op eenXC3S1400AN-5 FPGA.

generatormatrix G past niet in het interne geheugen van de FPGA: extern RAM-geheugen wordt voorzien.

3.1.2 Decryptie

Drie stappen hebben een significante bijdrage tot het totaal aantal klokcycli van dedecryptie. Een eerste pijnpunt is de berekening van syndroomveelterm Syn(z). Dezeveelterm bestaat uit een sommatie van gemiddeld n/2 = 1024 geïnverteerde lineaireveeltermen. De inversen worden bij elke decryptie-cyclus opnieuw berekend met hetuitgebreide algoritme van Euclides. De opslag van n = 2048 vooraf berekende inversenwordt afgewezen vermits hiervoor een geheugen van tnm = 608.256 bits vereist is.Het uitgebreide algoritme van Euclides is echter een zeer gecompliceerde bewerkingdie weinig of geen schaalvoordelen biedt bij een parallellisatie. Een uitgerolde versievan deze gecompliceerde bewerking resulteert dan ook in een enorme hoeveelheidlogica (≈ 64% van de decryptie-FPGA). Ook het kritisch pad van de decryptie FPGAwordt bepaald door deze bouwblok.

Een tweede pijnpunt is het vinden van de nulpunten van de foutlocatieveelterm.Het algoritme dat hiervoor gebruikt wordt, staat niet vermeld in de MicroEliece-

18

3.2. Parallelle neutralisatie van scramblingmatrix S.

paper. De basis van de eindig-veldelementen speelt in ieder geval een belangrijke rolhierbij, zoals bij alle veelterm algoritmes.

De neutralisatie van de scramblingmatrix vormt een derde struikelblok. Niet devector-matrix vermenigvuldiging zelf, maar het vullen van inverse scramblingmatrixS−1 hypothekeert de snelheid. De PRNG die hiervoor gebruikt wordt, is gebaseerdop het blokcijfer PRESENT.

Da precieze allocatie van de 20 interne RAM-blokken wordt niet toegelicht inde paper. De opslag van permutatievector π vereist 2 RAM-blokken. Mogelijkworden een aantal RAM-blokken aangewend voor het bufferen van in- en uitgaandedata. De meesten worden wellicht aangewend als conversietabellen voor de eindig-veldelementen: berekeningen gebeuren zowel de veeltermbasis als de exponentiëlebasis.

3.1.3 Eigen implementatie

Het eigen ontwerp gebruikt dezelfde parameterverzameling {n = 2048, k = 1751,t = 27} en wordt tevens gesynthetiseerd op dezelfde Spartan-3AN FPGA. Deresultaten bekomen in deze thesis zijn bijgevolg volledig vergelijkbaar met de reedsbestaande hardware-implementatie.

Deze thesis focust zich op het verbeteren van de kostelijke en trage decryptie. Desyndroomveelterm opbouw en het zoeken van de nulpunten van de foutlocatie veeltermvereisen een oplossing op algoritme-niveau. Een algoritme specifiek ontworpen voorhet inverteren van lineaire veeltermen (zie sectie 6.2), is veel efficiënter dan hetalgemene algoritme van Euclides. Het zoeken van nulpunten wordt onderworpen aaneen uitgebreide algoritme-exploratie in secties 6.1 en 6.5. Een alternatieve strategievoor het voorstellen van eindig-veldelementen wordt besproken in sectie 5.1. Beterealternatieven voor de PRESENT-PRNG worden eveneens onderzocht in sectie 4.1.De meerwaarde van een hardware-software co-design wordt toegelicht in sectie 3.3.Maar eerst wordt er een optimalisatie op systeemniveau besproken waarbij waarbijscramblingmatrix S geneutraliseerd wordt in parallel met Patterson’s algoritme.

3.2 Parallelle neutralisatie van scramblingmatrix S.

Het neutraliseren van scramblingmatrix S is één van de drie stappen met een signifi-cante bijdrage tot het totale aantal decryptie-klokcycli. De inverse scramblingmatrixS−1 moet gevuld worden met k2 = 3.066.001 bits van de PRNG. Het versnellen vandeze PRNG (meer bits per klokcyclus) is mogelijk ten koste van extra hardware.Twee cruciale optimalisaties versnellen de operatie op een alternatieve manier.

3.2.1 Introductie van een start-stop PRNG

De neutralisatie van S kan herschreven worden als een conditionële sommatie van derijen van S−1:

m = m′S−1 = m′0

(S−1

0,0 . . . S−10,k−1

)+ . . . + m′k−1

(S−1k−1,0 . . . S−1

k−1,k−1

).

19


Het is aannemelijk om m′ als een willekeurige boodschap van de Goppa-code tebeschouwen, waarbij elk element van de vector evenveel kans heeft om ‘0’ als ‘1’ tezijn. Gemiddeld gezien heeft slechts de helft van de rijen van S−1 een bijdrage tothet eindresultaat. We introduceren een PRNG die S−1 rij per rij opbouwt en diebovendien vanaf een arbitraire rij kan starten:

S−1 =(PRNG(0) PRNG(1) . . . PRNG(k − 1)

)T.

Hierbij is PRNG(i) een functie die k bits genereert voor rij i ∈ [0, k− 1] van S−1. Insectie 4.1 worden deze functie en de gebruikte PRNG meer in detail besproken. Degemiddelde productie van de PRNG per decryptie daalt tot k

2 × k ≈ 1.533.000 bits.

3.2.2 Parallelle neutralisatie

Hoewel de decryptieprocedure een sequentiële structuur heeft, kan men desondanksparallellisme introduceren indien de private Goppa-generatormatrix een systematischvorm heeft. De eerste k bits van het gecorrigeerde codewoord c′ vormen dan deboodschap m′. Figuur 3.1 toont de parallelle versie van algoritme 2.2; de volgordevan de eindig-veldelementen wordt vastgelegd door een teller (ai = i). De bestaandeFPGA-implementatie wacht tot alle fouten in het codewoord r′ verbeterd zijn enneutraliseert vervolgens S als allerlaatste stap. Men kan de neutralisatie van S echteral veel eerder starten op basis van de eerste k bits van r′. Eenmaal de nulpuntenen bijgevolg ook de bitfouten in r′ gevonden zijn, voeren we een correctie uit op deintussen geaccumuleerde boodschap m. Een bijkomende accumulatie van hoogstenst rijen van S−1 onthult de oorspronkelijke boodschap m. De gemiddelde productievan de PRNG per decryptie stijgt lichtelijk tot (k2 × k) + (t× k2/n) ≈ 1.573.421 bits.

3.3 Hardware-software co-design

Een degelijke uiteenzetting over hardware-software co-design kan men vinden in [49];we beperken ons hier tot de concepten toegepast in het eigen ontwerp. Het McEliece-algoritme bestaat uit een heel gamma aan rekenintensieve operaties. Hoewel hardware-bouwblokken hiervoor uitermate geschikt zijn, kan de introductie van software tocheen aanzienlijke meerwaarde betekenen. Er wordt gekozen voor een compactemicrocontroller die het globale cryptosysteem coördineert. Flexibiliteit ontspringtvanuit een systeem van reconfigureerbare interconnect tussen de veeltermbouwblokken:assembly-code bepaalt het busverkeer. Het softwaredeel voert zelf geen matrix- ofeindig-veldoperaties uit, maar bepaalt wel hoe deze in hardware moeten gebeuren.Aldus wordt een aanzienlijke hoeveelheid flexibiliteit bekomen zonder in te boetenaan snelheid.

Eerst wordt de keuze van de microcontroller toegelicht. Vervolgens wordt hetsysteem van reconfigureerbare interconnect (de bus) uitgelegd. Tenslotte wordt deconcrete interface tussen hardware en software besproken.

20

3.3. Hardware-software co-design

Syn(z) = 0for i = 0 to n− 1 do

if ri = 1 thenSyni(z) = 1/(z + aπ(i)) mod g(z)Syn(z) = Syn(z) + Syni(z)

end ifend forT (z) = Syn(z)−1 mod g(z)R(z) =

√T (z) + z mod g(z)

a(z) = b(z)R(z) mod g(z)σ(z) = a2(z) + zb2(z)Nulpunten σ(z) = {rooti}

m = 0for i = 0 to n− 1 do

if (ri = 1) & (π(i) < k) thenm = m+ PRNG(π(i))

end ifend for

for i = 0 to t− 1 doif rooti < k

m = m+ PRNG(rooti)end if

end for

�

-

?

?r

?m

Figuur 3.1: Parallellisatie van de McEliece-decryptie.

3.3.1 Keuze van de microcontroller

GEZEL ondersteunt hardware-software co-simulatie voor twee 8-bit microcontrollers:de PicoBlaze- en de 8051-processor. De PicoBlaze is een zeer compacte softcore-processor van Xilinx [45]. Deze RISC processor kan volledig gesynthetiseerd wordenop de belangrijkste Xilinx FPGA-families. De functionaliteit van de processor zit dusniet vervat in een gebruikelijke ASIC-implementatie, maar wordt in plaats daarvanbekomen met FPGA-bronnen. De zeer populaire 8051 (CISC) instructieset is met256 instructies veel rijker dan deze van de PicoBlaze die slechts 58 instructies heeft.Verscheidene fabrikanten (onder andere Intel, NXP Semiconductors, Infineon enTexas Instruments) hebben een eigen ASIC-implementatie van deze instructieset.

Voor de beoogde coördinerende functie geniet de PicoBlaze-processor een duideli-jke voorkeur. De beperkte functionaliteit van de PicoBlaze is hier eerder een voordeeldan een nadeel vermits ze resulteert in een compacte uitvoering. Het snelheidsvo-ordeel van de PicoBlaze is eveneens een doorslaggevende factor. Instructies wordenverwerkt in slechts twee klokcycli; de responstijd op een interrupt bedraagt vijfklokcycli. De maximale klok-frequentie is vergelijkbaar met deze van de hardwarebouwblokken op diezelfde FPGA. Aldus kan de snelheid concurrentieel blijven metde bestaande MicroEliece-implementatie. Wegens de afwezigheid van dataverwerking,volstaan de zestien 8-bit registers s0 tot en met sF ruimschoots. De PicoBlazeis eveneens uitgerust met een handige ZERO-vlag die bijgewerkt wordt bij elkeinstructie.

21


Figuur 3.2 toont de interface-signalen van de PicoBlaze. De IN_PORT enOUT_PORT maken een bytegewijze datastroom tussen hardware en software mo-gelijk. De READ_STROBE en WRITE_STROBE uitgangen genereren een klokpulsbij het inlezen en uitlezen van een byte respectievelijk. Aldus kan men hardwareen software synchroniseren. Het PORT_ID bepaalt de locatie waarop er lees- ofschrijfoperaties gebeuren. De assembly instructies worden opgeslagen door een FPGARAM-blok.

IN_PORT

INTERRUPT

RESET

CLK

OUT_PORT

PORT_ID

READ_STROBE

WRITE_STROBE

INTERRUPT_ACK

PicoBlaze

INSTRUCTION ADDRESS

8

8

8

DATA_OUT ADDRESSRAM Block

1810

Figuur 3.2: De PicoBlaze 8-bit RISC microcontroller.

3.3.2 Reconfigureerbare interconnect

CLK

COEFF_OUT COEFF_OUT_VALID

f(poly) µP

11

COEFF_IN COEFF_IN_VALID START

STOP

RESET

READY

LOAD_POLY1

LOAD_POLY2

EMPTY_POLY1

EMPTY_POLY2

11

status &

controle bits

Figuur 3.3: Generieke veeltermbouwblok.

22


De bus en het bijhorende protocol worden aanzienlijk vereenvoudigd door eenuniformisering van de aangesloten veelterm-bouwblokken. Elke veelterm-bouwblokheeft één of meer ingaande veeltermen en produceert hiermee één of meer uitgaandeveeltermen. Het in- en uitlezen van veeltermen gebeurt steeds coëfficiënt-gewijs.Hierdoor wordt het aantal datalijnen van de bus beperkt tot d = 11. De in- enuitgaande veeltermen hebben hoogstens graad t, meestal graad t−1 en soms graad t/2(bij benadering) of zelfs graad 0. Alle veeltermen op de bus worden gestandaardiseerdnaar graad t met behulp van leidende 0-coëfficiënten. Er is geen vaste conventie diede volgorde van de coëfficiënten vastlegt: een bouwblok die veeltermen, gesorteerdvolgens aflopende graad, naar een oplopende graad omzet en vice versa wordt voorzien.Figuur 3.3 toont een generieke versie van een veeltermbouwblok. De verticale pijlenstellen het in- en uitgaande busverkeer voor. Elke geldige coëfficiënt wordt steedsvergezeld van een hoog valid-signaal. De coördinerende functie van de PicoBlaze dievervat zit in de horizontale pijlen wordt besproken in de volgende sectie.

COEFF_IN

COEFF_IN_VALID

COEFF_OUT

COEFF_OUT_VALID

f1(poly)

MUX

MUX

11

CLK

COEFF_IN

COEFF_IN_VALID

COEFF_OUT

COEFF_OUT_VALID

f2(poly)

CLK

COEFF_IN

COEFF_IN_VALID

fn(poly)

CLK

COEFF_OUT

COEFF_OUT_VALID

Figuur 3.4: De veeltermbouwblokken voorzien van reconfigureerbare interconnect.

Alle veelterm-bouwblokken worden aangesloten op eenzelfde bus (zie figuur 3.4).De PicoBlaze controleert naast de aangesloten bouwblokken eveneens de multiplexersdie bepalen welke bouwblok als bus master beschouwd mag worden. Verschillendeaspecten van flexibiliteit zijn aanwezig. Allereerst zijn alle bouwblokken op de busonderling connecteerbaar, vermits ze allemaal aan eenzelfde interface-standaardvoldoen. De introductie van nieuwe bouwblokken op de bus is triviaal wat deschaalbaarheid ten goede komt. Bemerk wel dat de lastcapaciteit van de buslijnen

23


toeneemt naarmate er meer bouwblokken worden aangesloten. Wegens de sequentiëlestructuur van het Patterson algoritme, is de bus niet opgedeeld in segmenten.

START

READY

LOAD_POLY1

LOAD_POLY2

EMPTY_POLY1

COEFF_IN

COEFF_IN_VALID

COEFF_OUT

COEFF_OUT_VALID

poly poly

poly

f(poly)

Figuur 3.5: Tijdsdiagram van een generieke veeltermbouwblok.

Figuur 3.5 illustreert de controle-operaties van de PicoBlaze op een veelterm-bouwblok in het geval van twee ingaande en één uitgaande veelterm. Alle tijdssignalenzijn actief hoog. Een load-puls plaatst een veelterm-bouwblok in ontvangende modus.De geldige coëfficiënten worden zonder vertraging ingelezen: synchronisatie tussenveelterm-bouwblokken is steeds éénrichtingsverkeer. Na het inlezen van t+ 1 = 28coëfficiënten gaat de betreffende bouwblok opnieuw in ready-modus. Wanneer alleingaande veeltermen ingelezen zijn, kan de PicoBlaze de berekeningen starten meteen start-puls. Een hoog ready-signaal geeft aan wanneer deze afgerond zijn. DePicoBlaze maakt de bouwblok bus master en start de uitlezing met een empty-signaal.Bij het in- of uitlezen van meerdere veeltermen is de volgorde steeds arbitrair. Bemerkdat er ook een één-naar-velen connectie tot stand kan komen: een uitgelezen veeltermkan simultaan worden ingelezen door meerdere ontvangende bouwblokken. Verderkan er ook parallellisme geïntroduceerd kan worden: tijdens langdurige berekeningenvan een bepaalde bouwblok is de bus vrij voor ander verkeer.

3.3.3 Hardware-software interface

Figuur 3.6 toont een schematische voorstelling van de hardware-software interface.De statusbits van de alle afzonderlijke bouwblokken worden gegroepeerd per achtbits en kunnen via de IN_PORT ingelezen worden. Een multiplexer beslist opbasis van het PORT_ID welke set er verbonden wordt met de IN_PORT. Via eenINPUT-instructie wordt een gewenste set statusbits gekopieerd naar een registernaar keuze. De controle-operaties van de PicoBlaze vereisen doorgaans slechts dekennis van één statusbit tegelijk. De TEST-instructie wordt hiertoe aangewend alsmask-operatie: deze instructie correspondeert met een AND-operatie waarvan het

24


resultaat de ZERO-vlag beïnvloedt. Deze instructies worden steevast zo aangewenddat de ZERO-vlag identiek is aan de gewenste statusbit. Onderstaand codefragmentillustreert een leesoperatie.

INPUT s1, 01 register s1 bevat de status-signalen op locatie 0x01TEST s1, 08 maskeer register s1 met 0x08 - bit 4 bepaalt de ZERO vlagJUMP Z, label spring al dan niet naar een instructie-locatie

IN_PORT

INTERRUPT

RESET

OUT_PORT

PORT_ID

READ_STROBE

WRITE_STROBE

INTERRUPT_ACKPicoBlaze

7Decoder

MUX

8

status

bits

128

commando signalen

R

commando registers

8

CLK

R R

Figuur 3.6: De PicoBlaze-hardware interface.

De commandosignalen van de afzonderlijke bouwblokken vereisen doorgaans eenpulsvormige aansturing. Hiertoe wordt een specifieke waarde van het PORT_IDtoegekend aan elk van deze commandosignalen. Een decoder converteert hetPORT_ID eerst naar een één-hoog voorstelling; een set van AND-poorten diede WRITE_STROBE als gemeenschappelijke ingang hebben verzekeren vervolgensdat deze commandosignalen slechts één klokcyclus hoog blijven. Sommige comman-dosignalen moeten meerdere klokcycli hoog blijven. Eenzelfde constructie wordt dangebruikt om het enable-signaal van een één-bit register aangesloten op OUT_PORT0te bepalen. Typische assembly-code voor beide soorten commando’s ziet er als volgtuit:

OUTPUT s1, 3A puls op locatie 0x3A - de waarde van s1 is irrelevantLOAD s1, 01 register s1 bevat de waarde 0x01OUTPUT s1, 2F enable-signaal op locatie 0x2F

Bemerk dat er geen gebruik wordt gemaakt van interrupts: actief wachten (polling)

25


is de gekozen strategie om na te gaan of de berekeningen op een bouwblok reedsafgerond zijn. Vermits controle-operaties de enige taak zijn van de PicoBlaze, kandeze intussen toch geen nuttig werk leveren.

3.4 BesluitEen studie van de bestaande MicroEliece hardware-implementatie [16] op systeem-niveau resulteert in enkele belangrijke inzichten voor de eigen implementatie. DeMcEliece-encryptie is een heel eenvoudige procedure die helemaal gedomineerd wordtdoor een vector-matrix vermenigvuldiging; er is geen marge meer voor verdereoptimalisatie.

In deze thesis worden oplossingen gezocht voor de kostelijke decryptie. Eenvolledig opgevulde XC3S1400AN-5 decryptie-FPGA van de MicroEliece-implementatieheeft maar liefst 1.709.620 klokcycli nodig voor één enkele uitvoering. Drie stappenzijn bepalend voor het totale aantal klokcycli en krijgen bijgevolg het meeste aandacht.Een parallellisatie van de decryptie-procedure biedt een oplossing voor één van dezedrie stappen; de andere pijnpunten worden aangepakt in latere hoofdstukken.

Het eigen ontwerp vormt een middenweg tussen twee uitersten: lage-snelheidapplicatieszoals RFID-tags enerzijds en hoge-snelheidapplicaties voor bijvoorbeeld servers an-derzijds. Flexibiliteit wordt geïntroduceerd met behulp van een 8-bit microcontroller.Deze vervult de rol van hoofd-FSM en coördineert een systeem van reconfigureerbareinterconnect tussen de veelterm bouwblokken.

26

Hoofdstuk 4

Generatie sleutelmatrices

De private sleutel van McEliece bestaat uit inverse scramblingmatrix S−1, inversepermutatiematrix P−1 en Goppa generatorveelterm g(z): ze worden in deze volgordeachtereenvolgens besproken. De opbouw van publieke generatormatrix G op basisvan de private sleutel wordt daarna toegelicht.

Alle sleutels uitgezonderd S−1 worden vooraf berekend met de C/C++ referentie-implementatie en vervolgens getabelleerd. Voor bepaalde applicaties van het McEliececryptosysteem, is een volledige sleutelgeneratie in hardware wel wenselijk: met dezeuitbreiding wordt rekening gehouden bij het uitkiezen van de algoritmes. Mogelijkekansverdelingsproblemen bij een hardware-sleutelgeneratie worden eveneens bespro-ken.

4.1 Inverse scramblingmatrix S−1

De rijgewijze generatie van inverse S−1 met behulp van een PRNG werd beschrevenin sectie 3.2. De bekomen matrix moet uiteraard een inverteerbare matrix zijn: desingulariteit van willekeurige binaire matrices wordt besproken. Na het overlopenvan de zware PRNG-eisen, worden architecturen vergeleken die effectief aan dezeeisen voldoen. Tenslotte volgt een een bespreking van de gekozen architectuur envan de gerelateerde functie PRNG(i) die de rijen van S−1 vult.

4.1.1 Singulariteit van willekeurige binaire matrices

Beschouw de kans dat een willekeurige binaire matrix M van dimensie x singulier is:

Psing(x) = P (det(M) = 0 | M ∈ {0, 1}x×x).

Er zijn helaas geen gesloten uitdrukkingen voor deze kans. Voor grote dimensies zijner ook geen getabelleerde kansen ter beschikking. In de litteratuur kan men wel eenaantal bovengrenzen vinden [55]. De beste bovengrens is als volgt:

Psing(x) < (1− ε)x met ε = 10−3.

27

4. Generatie sleutelmatrices

Evaluatie van de bovengrens voor de dimensie van scramblingmatrix S resulteert in:

Psing(1751) < 17, 4%.

De kans op een niet-inverteerbare scramblingmatrix is zeker niet verwaarloosbaar,wat bevestigd kan worden door simulaties van de C/C + + referentie implementatie.

Een eerste strategie construeert de scramblingmatrix zodat deze per definitie in-verteerbaar is. Een LU-factorizatie splitst een matrix in een benedendriehoeksmatrixL en een bovendriehoeksmatrix U [38]. Indien men de diagonaalelementen ‘1’ kiest,bekomt men altijd een inverteerbare matrix:

S−1 = LU =

1 0? 1... . . . . . .? . . . ? 1

1 ? . . . ?

1 . . . .... . . ?

0 1

.Het aantal PRNG-bits om deze LU-factorizatie te vullen bedraagt k(k − 1) in plaatsvan k2. Een parallelle neutralisatie van S is nog steeds toepasbaar, zij het ondereen licht gewijzigde vorm. De asymmetrie van de AND-operator zorgt echter vooreen niet-uniforme kansverdeling van S−1 (en bijgevolg ook van S). Elementen in debovenste rijen van S−1 (uitgezonderd deze helemaal boven) zijn statistisch gezien veelvaker ‘0’ dan ‘1’. Idem voor de meest linkse kolommen. Een mathematische analysekan uitwijzen in hoeverre deze patronen de systematische vorm van G in G = SGPverhullen. Patronen in G kunnen op hun beurt informatie over de permutatiematrixgeven.

Om de veiligheid niet te ondermijnen, genereren we S−1 met een probabilistischestrategie. Willekeurige PRNG-sleutels worden geprobeerd totdat er één correspon-deert met een inverteerbare matrix. In de C/C+ + referentie code wordt een inversiealgoritme op basis van de Gauss-Jordan eliminatie geïmplementeerd. Aanzienlijkevereenvoudigingen voor binaire matrices zijn mogelijk ten opzichte van het algemenegeval. Algoritme 4.1 transformeert een binaire matrix naar rij-gereduceerde echelon-vorm [38]. Hierbij worden enkel elementaire rij-operaties gebruikt. De resulterendematrix voldoet aan de volgende drie eigenschappen:

1. Nul-rijen bevinden zich onderaan.

2. De leidende ‘1’ in een rij bevindt zich rechts van het leidende ‘1’ van de rijerboven.

3. Elk leidend ‘1’ is het enige niet-nul element in zijn kolom.

Toepassing van algoritme 4.1 op S−1 resulteert in een eenheidsmatrix indiendeze inverteerbaar is: S−1 ∼ I. De inverse S die vereist is voor de publieke sleutel,bekomt men door het hetzelfde algoritme toe te passen op een uitgebreide matrix:(

S−1 Ik)∼(Ik S

).

Het vereiste geheugen hiervoor bedraagt 2× k2 = 6.132.002 bits, wat relatief veel isvoor een hardware-implementatie van de sleutelgeneratie.

28

4.1. Inverse scramblingmatrix S−1

Algoritme 4.1 Rij-gereduceerde echelon vormIn: binaire a× b matrix MUit: M in rij-gereduceerde echelon vormcol_lead← 0row_lead← 0while (row_lead < a) & (col_lead < b) dorow_r ← row_leadwhile (M(row_r, col_lead) = 0) & (row_r < (a− 1)) dorow_r ← row_r + 1

end whileif M(row_r, col_lead) = 1 thenif row_r 6= row_lead thenverwissel rij row_r en rij row_leadfor row_i = 0 to a− 1 doif (row_i 6= row_r) & (M(row_i, col_lead) = 1) thenM(row_i, :)←M(row_i, :) + M(row_r, :)

end ifend for

end ifrow_lead← row_lead+ 1

end ifcol_lead← col_lead+ 1

end while

4.1.2 PRNG-eisen

Er worden drie eisen geformuleerd waaraan de PRNG moet voldoen. De PRNG moetallereerst cryptografisch veilig zijn, te bevestigen door twee soorten testen. De eersteis Yao’s test, met de next-bit test als meest eenvoudige formulering [59]. Verondersteldat een aanvaller de eerste i uitgangsbits kent. Het moet onmogelijk zijn om bit i+ 1te voorspellen in een aanvaardbare rekentijd (polynomiale tijdscomplexiteit). Alduswordt statische willekeurigheid van de uitgangsbits gegarandeerd. Een tweede typetest veronderstelt dat de huidige toestand van de PRNG gekend is door de aanvaller.Het moet in dat geval onmogelijk zijn om de de voorgaande bits te reconstrueren ineen aanvaardbare rekentijd.

De tweede eis houdt in dat de PRNG-productie moet kunnen starten vanafeen willekeurige rij van S−1. Zo niet wordt het onmogelijk om S te neutraliserenin parallel met Patterson’s algoritme. Indien de PRNG een initialisatie-procedurevereist, dan moet deze bij elke rij van S−1 opnieuw doorlopen worden.

Een hoge snelheid-oppervlakte ratio is de laatste eis. De gemiddelde productie perdecryptie bedraagt (k2 × k) + (t× k2/n) ≈ 1 573 421 bits. Het effectieve gemiddeldeis nog hoger omwille van twee redenen. Enerzijds de (herhaalde) initialisatie van dePRNG en anderzijds het feit dat matrixdimensie k = 1751 = 17× 103 wellicht geenveelvoud is van de PRNG-productie per klokcyclus.

29


4.1.3 PRNG-architecturen

Twee grote klassen voldoen aan de eerste twee eisen. De eerste klasse is deze van decryptografisch veilige blokcijfers (of hash-functies) in tel-mode. Na het al dan nietkiezen van een sleutel, worden opeenvolgende waarden van de teller geëncrypteerd.Verschillende startwaarden van de teller corresponderen met verschillende rijenvan S−1. De in essentie toestandsloze blokcijfers (of hash-functies) vereisen geeninitialisatie-procedure: de rijen van S−1 kunnen meteen gevuld worden. De tweedeklasse is deze van de cryptografisch veilige stroomcijfers. Pas na een initialisatie-procedure met een zekere sleutel en een initiële waarde (IV ), kan de productie starten.De initialisatie-waarden voor een zekere rij van S−1 zijn rechtstreeks afhankelijk vanhet betreffende rijnummer.

Bestaande hardware-implementaties van stroom- en blokcijfers bieden hulp. Intabel 4.1 worden FPGA-implementaties vergeleken die allemaal een hoge doorvoerhebben (meerdere bytes per klokcyclus). Stroomcijfers bieden dan veruit de bestesnelheid-oppervlakte ratio wegens de aanwezigheid van een toestandsvector. Voorbeperkte graden van parallellisme, verhoogt de oppervlakte veel minder dan rechtevenredig met de snelheid. Het versnellen van een blokcijfer of hashfunctie resulteertgewoonlijk in het ontrollen van een lus: de oppervlakte verhoogt dan recht evenredigmet de snelheid. Het stroomcijfer TRIVIUM heeft veruit de hoogste snelheid-oppervlakte ratio en wordt bijgevolg geïmplementeerd.

Stroomcijfer Sleutel Doorvoer Oppervlakte fmax Platform(bits) (bits/klokcyclus) (# slices) (MHz)

TRIVIUM [22] 80 32 264 202 Spartan-3TRIVIUM [22] 80 64 388 190 Spartan-3Grain-128 [32] 128 32 534 133 Spartan-3MUGI [35] 128 64 1964 110 Virtex-IIRabbit [51] 128 32 588 + 6 DSP 195 Virtex-VRabbit [51] 128 128 884 + 24 DSP 137 Virtex-VBlokcijfer Sleutel Doorvoer Oppervlakte fmax Platform

(bits) (bits/klokcyclus) (# slices) (MHz)TDES [36] 128 64 14240 108 VirtexIDEA [36] 128 64 11700 47 Virtex

CAST-128 [36] 128 64 24200 53 VirtexMISTY1 [36] 128 64 13080 26 VirtexKHAZAD [36] 128 64 9277 70 VirtexHashfunctie Doorvoer Oppervlakte fmax Platform

(bits/klokcyclus) (# slices) (MHz)BLAKE-64 [1] 68, 26 4329 35 Virtex-VKeccak [4] 56, 56 1412 122 Virtex-V

Skein-512-512 [52] 52, 50 4273 27 Spartan-3

Tabel 4.1: Hoge-doorvoer FPGA-implementaties van stroom- en blokcijfers en vanhashfuncties.

30

4.1. Inverse scramblingmatrix S−1

Voor een lage doorvoer zijn stroom- en blokcijfers zeer concurrentiëel, zoalsblijkt uit de vergelijking van ASIC-implementaties in tabel 4.2. Het verschil insnelheid-oppervlakte ratio tussen bijvoorbeeld TRIVIUM en PRESENT (gebruiktin de MicroEliece-implementatie [16]) is niet spectaculair. Bij een toename van dedoorvoer, zal dit verschil wel spectaculair worden.

Stroomcijfer Sleutel Doorvoer Oppervlakte Technologie(bits) (bits/klokcyclus) (GE)

Edon80 [34] 80 1/80 = 0, 013 2922 0, 35 µmTRIVIUM [19] 80 1 2390 0, 35 µm

Blokcijfer Sleutel Doorvoer Oppervlakte Technolgie(bits) (bits/klokcyclus) (GE)

AES-128 [21] 128 128/1032 ≈ 0, 124 3400 0, 35 µmHIGHT [30] 128 64/34 ≈ 1, 882 3048 0, 25 µm

PRESENT-80 [6] 80 64/32 = 2 1570 0, 18 µmmCrypton [40] 96 64/13 ≈ 4, 923 2681 0, 13 µmKATAN64 [12] 80 64/85 ≈ 0, 753 1269 0, 13 µm

KTANTAN64 [12] 80 64/85 ≈ 0, 753 1168 0, 13 µmHashfunctie Doorvoer Oppervlakte Technologie

(bits/klokcyclus) (GE)BLAKE-64 [1] 4, 55 19460 0, 18 µmKeccak [4] 0, 265 5000 0, 13 µm

Hamsi-256 [18] 4, 571 22000 0, 13 µm

Tabel 4.2: Lage-doorvoer ASIC-implementaties van stroom- en blokcijfers en vanhashfuncties.

4.1.4 PRNG-implementatie

Het TRIVIUM-stroomcijfer heeft een toestandsvector s met een lengte van 288 bits[11]. Herhaalde update van toestandsvector s resulteert in een stroom van pseudo-random bits (zie algoritme 4.2). Een schematische voorstelling die het voorgaandealgoritme verduidelijkt wordt hier hernomen als figuur 4.1.

De initiële toestand van s wordt bepaald door een 80-bit sleutel en een 80-bitIV . De eerste 4× 288 = 1152 uitgangsbits zijn ongeldig (zie algoritme 4.3).

Een hardware-implementatie is zeer eenvoudig te voorzien van parallellisme. Tenkoste van 3 AND-poorten en 11 XOR-poorten verkrijgt men telkens een extra bitper klokcyclus. Pas vanaf 70 bits per klokcyclus ligt het kritische pad hoger danT = TAND + 2TXOR. De eigen GEZEL-implementatie is gebaseerd op deze van [49].

We bepalen een functie PRNG(i), zoals gedefiniëerd in sectie 3.2. Voor elkeinitialisatie (dus voor elke rij van S−1), wordt dezelfde sleutel gebruikt. De IVkiezen we telkens gelijk aan het rijnummer i ∈ [0, k − 1]. De C/C++ referentie-implementatie controleert of een gegeven sleutel resulteert in een inverteerbare S−1.De PRNG-productie per rij van S−1 bedraagt minstens 1152 + k = 2903 bits, in

31


Algoritme 4.2 TRIVIUM-cyclusIn: toestandsvector sUit: pseudo-random bit ztoestandsvector st1 ← s65 + s92t2 ← s161 + s176t3 ← s242 + s287z ← t1 + t2 + t3t1 ← t1 + s90 s91 + s170t2 ← t2 + s174 s175 + s263t3 ← t3 + s285 s286 + s68(s0, s1, . . . , s92)← (t3, s0, . . . , s91)(s93, s94, . . . , s176)← (t1, s93, . . . , s175)(s177, s178, . . . , s287)← (t2, s177, . . . , s286)

Figuur 4.1: Schematische voorstelling van het TRIVIUM-stroomcijfer.

32

4.2. Inverse permutatiematrix P−1

Algoritme 4.3 TRIVIUM initialisatieUit: toestandsvector s

(s0, s1, . . . , s92)← (K0, . . . ,K79, 0, . . . , 0)(s93, s94, . . . , s176)← (IV0, . . . , IV79, 0, . . . , 0)(s177, s178, . . . , s287)← (0, . . . , 0, 1, 1, 1)Doorloop 4× 288 TRIVIUM-cycli

tegenstelling tot k = 1751 bits bij een blokcijfer of hashfunctie. Wegens het enormeperformantie-verschil bij een grote PRNG-doorvoer, wordt dit verschil echter ruimgecompenseerd.

4.2 Inverse permutatiematrix P−1

Een compacte representatie in het geheugen van zowel P als inverse P−1 = P T werdreeds ingeleid in sectie 2.5 en wordt hier meer in detail besproken. Daarna wordteen generatie-algoritme gezocht dat tevens de mogelijkheid biedt tot een compactehardware-implementatie.

4.2.1 Vereiste opslagruimte

Beide n × n kolom-permutatiematrices kunnen compact worden voorgesteld dooreenzelfde permutatievector π =

(π(0) π(1) . . . π(n− 1)

). Hierbij is de functie

π(i) een bijectie van de verzameling kolomindices {0, 1, . . . , n − 1} naar zichzelf.De vereiste opslagruimte bedraagt n× log2(n) = 22.528 bits. We relateren permu-tatievector π tot de permutatiematrices zodat de inverse permutatie in opzoek-vormbeschikbaar is:

P =(π(0) π(1) . . . π(n− 1)

0 1 . . . n− 1

),

P−1 =(

0 1 . . . n− 1π(0) π(1) . . . π(n− 1)

).

De gekozen voorstelling is gunstig voor het decryptie-proces: de berekening vansyndroom veelterm Syn(z) en de toepassing van P−1 op de cijfertekst r kunnenin parallel. Ten koste van een verdubbelde opslagruimte, kan men ook over P inopzoek-vorm beschikken:

P =(

0 1 . . . n− 1π−1(0) π−1(1) . . . π−1(n− 1)

).

Aangezien de sleutelgeneratie doorgaans niet tijdskritisch is, kan men deze bijkomendeopslagruimte evengoed weglaten in een hardware-implementatie.

33


4.2.2 Keuze van het algoritme

Twee klassen algoritmes resulteren in een willekeurige permutatievector. In beidegevallen wordt deze geïnitialiseerd als π =

(0 1 . . . n− 1

). De eerste klasse

maakt gebruikt van een efficiënt sorteringsalgoritme. Aan elke vectorindex i wordteen willekeurig getal toegekend. De willekeurige waarden worden gesorteerd volgensgrootte en de corresponderende vectorelementen π(i) verhuizen mee. Een aantalnadelen zijn onlosmakelijk verbonden met deze algoritmes. Extra aandacht is vereistin het geval van identieke random waarden. Verder is de tijdscomplexiteit minstensO(n× log(n)), afhankelijk van het sorteringsalgoritme. De tweede klasse algoritmesmaakt gebruik van herhaalde omwisseling van de elementen van de geïnitialiseerdevector π. Er wordt gekozen voor de Durstenfeld modificatie van het Fisher-Yatesalgoritme [14], hier hernomen als algoritme 4.4. Het Durstenfeld algoritme is nietalleen eenvoudig, maar heeft bovendien tijdscomplexiteit O(n).

Algoritme 4.4 DurstenfeldUit: permutatievector π van lengte nfor i = 0 to n− 1 doπ[i]← i

end forfor i = n− 1 to 1 dokies willekeurig r ∈ [0, i]verwissel π[i] en π[r]

end for

Het random getal r ∈ [0, i] moet voor elke i een uniforme kansverdeling hebben.Dit is niet evident aangezien een Random Number Generator doorgaans binairewaarden produceert. Een voor de hand liggende modulo i + 1 operatie op deuitgangsbits kan aanleiding geven tot een bias. Het genereren van een nieuw getal rindien het vorige niet in het gewenste bereik ligt, biedt een oplossing.

4.3 Generatorveelterm g(z)

Een willekeurige monische irreduceerbare veelterm g(z) van graad t over het eindigveld GF (2d) definieert de veeltermbewerkingen. We gebruiken een probabilistischemethode voor de generatie ervan: willekeurige monische veeltermen worden getesttotdat er één irreduceerbaar is. De kans dat een monische veelterm irreduceerbaaris, wordt nader toegelicht. Deze bepaalt immers het gemiddelde aantal iteraties.Verder wordt er een irreduceerbaarheidstest gezocht die een compacte hardware-implementatie mogelijk maakt.

34

4.3. Generatorveelterm g(z)

4.3.1 Irreduceerbaarheid van willekeurige veeltermen

Beschouw alle N = 2dt monische veeltermen van graad t over het veld GF (2d). Hetaantal irreduceerbare veeltermen bedraagt

I = 1t

∑i|tµ(i)2dt/i,

met µ de Möbius functie [43]. De Möbius functie heeft −1, 0 en 1 als mogelijkeuitkomsten, afhankelijk van de factorisatie van i in priemfactoren. Het aantalirreduceerbare veeltermen laat zich benaderen door

I ≈ 1t2mt.

De kans op slagen bedraagt dus eenvoudigweg

P = N/I ≈ 1/t.

Na gemiddeld t pogingen bekomt men een geldige generator veelterm g(z).

4.3.2 Test voor irreduceerbaarheid

De Ben-Or irreduceerbaarheidstest (hier hernomen als algoritme 4.5) is een relatiefeenvoudige procedure [23]. Hoogstens bt/2c iteraties zijn vereist om een veeltermals reduceerbaar te klasseren. De veelterm z2di + z is het product van alle monischeirreduceerbare veeltermen over GF (2d) waarvan de graad een deler is van i. Deveelterm g(z) wordt dus stapsgewijs onderzocht op irreduceerbare factoren van graadi. De graad van de kleinste irreduceerbare factor bedraagt hoogstens bt/2c voor elkereduceerbare g(z). Het algoritme is efficiënt vermits veel reduceerbare veeltermeneen factor van een lage graad hebben; deze worden dan ook snel verworpen.

Algoritme 4.5 Ben-Or test voor irreduceerbaarheidIn: monische veelterm g(z) van graad t over het veld GF (2d)Uit: ‘reduceerbaar’ of ‘irreduceerbaar’for i = 1 to bt/2c dogcd(z)← gcd(g(z), z2di + z mod g(z))if gcd heeft graad > 1 thenreturn ‘reduceerbaar’

end ifend forreturn‘irreduceerbaar’

De grootste gemene deler kan men berekenen met het uitgebreide algoritme vanEuclides. De berekening van de machten z2mi voor i = 1, 2, . . . , bt/2c gebeurt doormiddel van herhaalde kwadratering; de onderliggende relatie is als volgt:

z2m(i+1) = (z2mi)2m.

35


4.4 Publieke generatormatrix G

De publieke generatormatrix wordt opgebouwd vanuit de private sleutel: G = SGP .Zowel eindig-veld- als veeltermbewerkingen zijn vereist om een systematische Goppa-generatormatrix G te vinden die strookt met de generatorveelterm g(z). Eerst wordteen pariteitscontrolerende matrix H opgebouwd, zoals beschreven in sectie 2.2.2.Elementaire rij-operaties brengen H in systematische vorm:

H ∼(In−k X

).

De systematische generatormatrix G laat zich schrijven als volgt:

G =(Ik XT

).

De getransformeerde publieke generatormatrix G hoeft niet als een expliciete ver-menigvuldiging van matrices berekend te worden. De vermenigvuldiging met kolom-permutatiematrix P wordt doorgevoerd via de corresponderende permutatievectorπ. De inversie van de PRNG-gegenereerde S−1 en de daaropvolgende matrix-matrixvermenigvuldiging SG (of S(GP )) kunnen in eenzelfde stap gebeuren met behulpvan algoritme 4.1: (

S−1 G)∼(Ik SG

).

Het vereiste werkgeheugen hiervoor bedraagt k(k + n) = 6.652.049 bit. Bemerk dathet gebruikte algoritme destructief is: indien S−1 niet inverteerbaar blijkt, moetG (of GP ) opnieuw worden opgebouwd. Er wordt in dat geval ook een anderePRNG-sleutel gekozen die hopelijk wel correspondeert met een inverteerbare S−1.

4.5 Niet-uniforme kansverdeling problematiek

Drie willekeurige entiteiten (twee matrices en één veelterm) vormen samen de privatesleutel. In het ideale geval hebben ze een uniforme kansverdeling: de verschillendeverschijningsvormen van deze entiteiten zijn allemaal even waarschijnlijk. Indien zeniet gegenereerd worden met een ware Random Number Generator, maar met eenPRNG, dan kunnen er niet-uniforme kansverdelingen ontstaan.

Het fundamentele probleem hierbij is de beperkte toestandsruimte van zo’nPRNG: de grootte ervan moet vergeleken worden met het aantal verschillendeverschijningsvormen van de ermee gegeneerde entiteiten. Bij de eigen implementatiewordt enkel de inverse scramblingmatrix met een hardware-PRNG gegenereerd. Tabel4.3 geeft een overzicht alle entiteiten voor de volledigheid. Bemerk dat een eventuelehardware-sleutelgeneratie van g(z) en P best gebeurd met een ware Random NumberGenerator vermits reproduceerbaarheid niet vereist is.

De TRIVIUM-PRNG bijvoorbeeld heeft slechts 2160 verschillende initiële toestan-den wegens de 10-byte sleutel en de 10-byte IV. Het aantal verschijningsvormen vaninverse scramblingmatrix S−1 wordt beperkt door de toestandsruimte van de PRNG.De toestandsruimte is echter nog altijd veel groter dan 280, het veiligheidsniveau van

36

4.6. Besluit

Private sleutel Aantal verschijningsvormenPermutatiematrix P (of inverse P T ) 219580 < n! < 219581

Scramblingmatrix S (of inverse S−1) 23066000 < 0, 9 2k2< 23066001

Goppa generatorveelterm g(z) 2292 < 1t 2mt < 2293

Tabel 4.3: Niet-uniforme kansverdeling problematiek van de private sleutel.

McEliece voor de gekozen parameters. Dit doet vermoeden dat de veiligheid nietgereduceerd kan worden met een specifieke aanval waarbij de specificaties van degebruikte PRNG uitgebuit worden.

4.6 BesluitDe generatie van enerzijds de private sleutel {S−1, P−1, g(z)} en anderzijds depublieke sleutel G = SGP werd besproken. Efficiënte algoritmes die geschikt zijnvoor een hardware-implementatie werden gezocht en gevonden voor de private sleutel.Een generatie in hardware van de gerelateerde publieke sleutel vereist echter eentijdelijk werkgeheugen van minstens 2k2 = 6.132.002 bits, of zelfs k(k + n) =6.652.049 bits in ruil voor een aanzienlijke verhoging van de snelheid. Voor hoog-performante toepassingen is dit geheugen normaliter beschikbaar in tegenstellingtot de lichtgewicht cryptografietoepassingen. Compacte implementaties met voorafberekende sleutels worden echter niet uitgesloten op basis van dit hoofdstuk: deopslagruimte voor de private sleutel wordt gedomineerd door P−1 en bedraagtcirca 23 kbit. De publieke sleutel is veel groter maar hoeft uiteraard niet privaatgehouden te worden. In deze thesis worden de sleutels vooraf berekend met deC/C++ referentie-implementatie. Bemerk hierbij dat S−1 tevens reproduceerbaar isin hardware.

37

Hoofdstuk 5

Eindig-veldoperaties

Dit hoofdstuk behandelt alle basisoperaties in het eindig veld GF (211). De exploratievan veeltermalgoritmes in hoofdstuk 6 wijst uit dat zeven bewerkingen ondersteundmoeten worden: optelling, vermenigvuldiging, vermenigvuldiging met het element x,(multiplicatieve) inversie, deling, kwadratering en het nemen van de vierkantswortel.De eindig-veldoperaties komen eerst aan bod vermits een aantal veeltermalgoritmesveralgemeningen zijn van de hier besproken methodes.

Alle eindig-veldoperaties gebeuren in een bepaalde basis modulo een zekereirreduceerbare veelterm f(x). Alvorens de afzonderlijke operaties te bespreken,wordt dit gemeenschappelijke kader vastgelegd. De keuze van de basis heeft eengrote invloed op de totale performantie van de decryptie en vereist bijgevolg extraaandacht. Er wordt gekozen voor een fundamenteel andere strategie dan deze van deMicroEliece-paper [16]. GEZEL-implementaties van de besproken operaties wordengegeven in appendix B.

5.1 Basis van de eindig-veldoperatiesDe complexiteit van de operaties (en dus ook van de bovenliggende veelterm-bouwblokken) is sterk afhankelijk van de gekozen basis. Door de veelvuldigheid aanoperaties, is er geen basis die er duidelijk uitspringt. Eerst worden twee veelgebruiktebasissen toegelicht: de veeltermbasis en de exponentiële basis. De eigen strategiewordt gecontrasteerd met deze van de MicroEliece-implementatie.

5.1.1 Veeltermbasis versus exponentiële basis

De veeltermbasis is uitermate geschikt voor de optelling; de exponentiële basis is danweer te verkiezen voor alle andere operaties. De veeltermbasis beschouwt de bits vaneen eindig-veldelement als coëfficiënten van de binaire veelterm:

a(x) = a10x10 + a9x

9 + . . .+ a1x+ a0 met ai ∈ {0, 1}.

De optelling van twee elementen is simpelweg een XOR-operatie op de correspon-derende coëfficiënten. De exponentiële basis beschouwt de bits van een eindig-

39

5. Eindig-veldoperaties

veldelement als de exponent van een generatorelement α van het eindig veld:

a = αi met i ∈ [0, 2046].

Het nul-element wordt voorgesteld door i = 2047, maar is in feite geen macht vanhet generatorelement. Alle bewerkingen uitgezonderd de optelling herleiden zich tothet berekenen van een nieuwe exponent.

5.1.2 Strategie van de MicroEliece-implementatie

Een eerste strategie is het gebruik van beide voorstellingen, zoals in de MicroElieceimplementatie. De bewerkingen gebeuren telkens in de meest geschikte basis, meteenvoudige logica tot gevolg. Conversie van basis is mogelijk met behulp van tweevooraf berekende omzettingstabellen (de log en antilog tabel). De veeltermbasiswordt gebruikt als standaard voorstelling en zorgt voor de optelling. Alle andereeindig-veldoperaties vereisen zes klokcycli: twee klokcycli voor het berekenen vaneen nieuwe exponent en vier klokcycli voor de heen- en terug-conversie.

Deze strategie gaat echter ten koste van zowel geheugen als performantie. Devereiste geheugenruimte bedraagt 2× n× d = 45056 bit. Het verlies aan snelheid istweeledig. Enerzijds zorgt elke RAM-leesoperatie voor een vertraging van minstenséén klokcyclus (twee in de MicroEliece implementatie). Anderzijds wordt elke vormvan parallellisme bemoeilijkt aangezien RAM-geheugen doorgaans slechts één oftwee toegangspoorten heeft. Het gebruik van meer dan twee omzettingstabellen kanhiervoor een oplossing bieden ten koste van nog meer geheugenruimte.

Het uitgerolde algoritme van Euclides vormt een belangrijke uitzondering op dezestrategie: t = 27 combinatorische vermenigvuldigers die opereren in de veeltermbasisworden voorzien. Dergelijke vermenigvuldigers vereisen echter een aanzienlijke ho-eveelheid logica en dragen hun steentje bij tot enorme oppervlakte van de betreffendebouwblok.

5.1.3 Eigen strategie

De gekozen strategie voor de eigen implementatie is het gebruik van één enkelevoorstelling, namelijk deze met de veeltermbasis. Twee argumenten zijn hierbijdoorslaggevend. Allereerst is de optelling, de meeste voorkomende operatie samenmet de vermenigvuldiging, zeer eenvoudig. Verder is er heel wat vaklitteratuurbeschikbaar over de implementatie van de vijf andere operaties in deze veeltermba-sis. Alle basisoperaties worden bit-parallel uitgevoerd om de performantie van debovenliggende veelterm-bouwblokken niet te hypothekeren. Het gebruik van ver-menigvuldigers (en eventuele andere eindig-veldbouwblokken die hierop gebaseerdzijn) wordt tot een minimum beperkt.

5.2 Keuze van de irreduceerbare veelterm.Er zijn 186 irreduceerbare veeltermen die het veld GF (211) kunnen definiëren [26].Bepaalde klassen van irreduceerbare veeltermen geven aanleiding tot beduidend

40

5.3. Vermenigvuldiging

minder logica in de eindig-veldbouwblokken. De vermenigvuldiging is bepalend voordeze keuze aangezien het samen met de optelling de meest voorkomende operatieis. Bovendien is er een aanzienlijke hoeveelheid logica vereist voor de implementatieervan. Alle resterende operaties die via de kleine stelling van Fermat herleid wordentot één of meer vermenigvuldigingen, verscherpen deze stelling. Meestal zijn erechter veel efficiëntere alternatieven ter beschikking voor die operatoren. De trinoomf(x) = x11 + x2 + 1 blijkt niet alleen optimaal voor de vermenigvuldiging (zie sectie5.3), maar is ook zeer gunstig voor de berekening van een kwadraat of vierkantswortel(zie sectie 5.5) en voor de vermenigvuldiging met x (zie sectie 5.4).

5.3 VermenigvuldigingEen vergelijkende studie van de bestaande klassen bit-parallelle vermenigvuldigersin GF (2d) is aangewezen bij het kiezen van een irreduceerbare veelterm [58]. Dearchitectuur van al deze klassen is zeer gelijkaardig (zie figuur 5.1). Het AND-netwerk zorgt voor het product van elk paar coëfficiënten aibj met i, j ∈ [0, d− 1].Het aantal AND-poorten is steeds d2. Een eerste XOR-netwerk zorgt voor hetuitgerolde veeltermproduct

s(x) = a(x)b(x) =2d−2∑k=0

skxk met sk ∈ GF (2).

Een tweede XOR-netwerk zorgt voor de reductie modulo de irreduceerbare veeltermf(x) en is bijgevolg verschillend voor alle klassen. Tabel 5.1 vergelijkt de complexiteitvan alle klassen. Een Equally Spaced Polynomial (ESP) bevat enkel termen waarvande machten een veelvoud zijn van een natuurlijk getal s > 0. Een bijzonder gevalhiervan zijn de All-One Polynomials (s = 1) die het maximum aantal termen bevatten.Trinomen en pentanomen bestaan uit drie en vijf termen respectievelijk. De typesvoorgesteld in [58] worden allemaal gekenmerkt door een terugkerend patroon per drieopeenvolgende termen. Het bestaan van alle deze types irreduceerbare veeltermenwordt nagegaan voor het geval d = 11. De trinoom f(x) = x11 + x2 + 1 is zowelin termen van oppervlakte als snelheid de beste keuze. De intermediaire signalenvan de XOR-netwerken staan beschreven in [57]. Het resulterende vermenigvuldigerbouwblok bevat 121 AND-poorten en 120 XOR-poorten en heeft een vertragingT = TAND + 6 TXOR.

AND-netwerk XOR-netwerk 1 XOR-netwerk 2121 20 11

11

11

a

b

c

Figuur 5.1: Architectuur van de eindig veld bit-parallelle vermenigvuldiger metd = 11.

41


Klasse # XOR’s Vertraging (# TXOR) d = 11s-ESPxd + . . .+ x2s + xs + 1 d2 − s dlog2de+ 1Trinoom xd + xk + 1k = 1 d2 − 1 dlog2de+ 12 ≤ k ≤ d

2 d2 − 1 dlog2(d− 1)e+ 2 Xk = d

2 d2 − d2 dlog2de+ 1

Pentanoom xd + xk3 + xk2 + xk1 + 1k1 > 1 d2 + 2d− 3 dlog2(d− 1)e+ 4 Xk1 = 1 d2 + 2d− 3 dlog2(d− 1)e+ 3 Xki = d− is, d− 1 < h < d− 1 ≤ d2 + d dlog2(d− 1)e+ 4Wu [58]Type I d2 + d− 3 dlog2(d− 3)e+ 3Type II d2 + d− 3 dlog2(d− 3)e+ 3Type III d2 + d− 3 dlog2(d− 3)e+ 3

Tabel 5.1: Vergelijking van bit-parallelle vermenigvuldigers.

5.4 Vermenigvuldiging met het element x

Wegens de complexiteit van de algemene vermenigvuldiging, loont het de moeiteom een meer specifieke bouwblok te gebruiken voor de vermenigvuldiging van eeneindig-veldelement met x. Indien de meest significante term van veeltermvoorstelling

a(x) = ad−1xd−1 + ad−2x

d−2 + . . .+ a1x+ a0

niet aanwezig is, herleidt deze bewerking zich tot een schuifoperatie op de coëfficiënten.In het andere geval is er ook nog een reductie modulo de irreduceerbare veeltermf(x) vereist. Een conditionele optelling (XOR-operatie) van de verschoven versie enf(x) op basis van coëfficiënt ad−1 volstaat. De resulterende implementatie van figuur5.2 bevat slechts één XOR-poort voor de irreduceerbare trinoom f(x) = x11 + x2 + 1.

5.5 Kwadraat en vierkantswortelEen vermenigvuldiger met kortgesloten ingangssignalen levert de functionaliteit vaneen kwadratuur-operator. De vierkantswortel-operator herleidt zich via de kleinestelling van Fermat tot een meervoudige vermenigvuldiging:

√a = a2d−1 . Een matrix-

gebaseerde architectuur daarentegen is, zeker in het geval van de vierkantswortel,veel efficiënter.

5.5.1 Matrix-gebaseerde berekening

In [48] wordt een matrix-gebaseerde methode beschreven die toepasbaar is voorbeide operaties. Corresponderende analytische vergelijking voor verschillende typesirreduceerbare trinomen werden reeds voorberekend. Vermits men deze methode ook

42

5.6. Inversie en deling

c9 c7 c5 c3 c2 c0

a10 a9 a8 a7 a6 a5 a4 a3 a2 a1 a0

c10 c8 c6 c4 c1

Figuur 5.2: Architectuur van de eindig veld vermenigvuldiging met x.

kan veralgemenen naar veeltermen over een eindig veld, wordt ze toch even toegelicht.De elementen van het eindig veld worden voorgesteld als vectoren:

a(x) = a0 + a1x+ . . .+ ad−2xd−2 + ad−1x

d−1 =(a0 a1 . . . ad−2 ad−1

)Men zoekt de binaire d× d matrix M waarvoor geldt dat:(

1 x2 . . . x2(d−2) x2(d−1))

=(

1 x . . . xd−2 xd−1)M mod f(x).

Kolom i van matrix MT correspondeert met het eindig-veldelement x2i. De eerstedd/2e kolommen van MT bevatten slechts één ‘1’. Ook de andere kolommen zijn zeerspaars in het geval van irreduceerbare trinomen. Het kwadraat en een vierkantswortelvan een eindig-veldelement a kan men uiteindelijk berekenen met een binaire vector-matrix vermenigvuldiging:

a2 = aMT

√a = aM−T

5.5.2 Hardware-implementatie

De zeer spaarse MT en M−T matrices worden impliciet gerealiseerd: de resulterendekwadratuur- en vierkantswortelbouwblokken bevatten slechts zes XOR-poorten (ziefiguren 5.3 en 5.4). De vertraging T bedraagt respectievelijk TXOR en 5 TXOR. Devertraging van de vierkantswortelbouwblok kan gereduceerd worden tot 3 TXOR inruil voor drie extra XOR-poorten.

5.6 Inversie en delingDe deling wordt herleid tot de vermenigvuldiging van het deeltal met de inversevan de deler. Voor de inversie zijn er in essentie twee methoden ter beschikking

43


c9 c7 c5 c3 c2 c0

a10 a9 a8 a7 a6 a5 a4 a3 a2 a1 a0

c10 c8 c6 c4 c1

Figuur 5.3: Architectuur van de eindig veld kwadratuurbouwblok.

c9

c7

c5

c3

c2

c0

a10

a9

a8

a7

a6

a5

a4

a3

a2

a1

a0

c10

c8

c6

c4

c1

Figuur 5.4: Architectuur van de eindig veld vierkantswortelbouwblok.

[33, 37]. De eerste methode gebruikt de vermenigvuldiging. Uit de kleine stellingvan Fermat volgt dat a−1 = a2d−2. De inverse kan herschreven worden als eenproduct van kwadratuur-operaties: a−1 =

∑d−1k=1 a

2k . Deze methode wordt gekozenter implementatie: de resulterende bouwblok bevat één vermenigvuldiger en éénkwadratuur-operator waarover geïtereerd wordt.

Verscheidene varianten van het uitgebreide algoritme van Euclides zijn achterafgezien iets minder kostelijk. De variant die hier wordt hernomen als algoritme5.1 vermijdt de gecompliceerde staartdeling van het oorspronkelijke algoritme. Deinversie van veeltermen over het eindig veld wordt tevens geïmplementeerd met eenveralgemeende versie van deze variant.

44

5.7. Besluit

Algoritme 5.1 Variant van het uitgebreide algoritme van EuclidesIn: irreduceerbare veelterm f(x)

eindig-veldelement a(x)Uit: veelterm y(z)

veelterm v(z)x(x)← f(x)y(x)← a(x)u(x)← 0v(x)← 1degx← degree(x(x))degy ← degree(y(x))while degy > 0 doif degx < degy thenverwissel x(x) en y(x)verwissel degx en degyverwissel u(x) en v(x)

end ifδ ← degx− degyx(x)← x(x) + xδy(x)u(x)← u(x) + xδv(x)degx← degreex(z)

end while

5.7 BesluitConcrete architecturen voor alle eindig-veldoperaties werden besproken; ze liggen aande basis van de veeltermalgoritmes in het volgende hoofdstuk. Alle operaties gebeurenin dezelfde veeltermbasis, wat een performantie-voordeel oplevert ten opzichte vande MicroEliece-implementatie. Voor vier van de zeven bewerkingen werd een zeercompacte architectuur bekomen: de optelling, de vermenigvuldiging met x, dekwadratering en het nemen van de vierkantswortel. Met de drie overblijvende enzeer kostelijke vermenigvuldiging-gebaseerde bouwblokken moet verstandig wordenomgesprongen: ze worden enkel ingezet wanneer hun rendement voldoende hoog is.

45

Hoofdstuk 6

Veeltermalgoritmes

Dit hoofdstuk behandelt de vereiste veeltermoperaties op algoritmeniveau. Ze steunenop de eindig-veldoperaties besproken in hoofdstuk 5. De meeste veeltermoperatiesdienen ter ondersteuning van Patterson’s algoritme in de McEliece-decryptie. Ookde McEliece-sleutelgeneratie vereist een aantal veeltermoperaties voor de Ben-Orprocedure enerzijds en het vullen van de Goppa pariteitscontrolerende matrix Handerzijds.

De benodigde functionaliteiten worden steeds onderworpen aan een algoritme-exploratie: de meest geschikte uit een set van verscheidene methodes wordt uitein-delijk geïmplementeerd. GEZEL-implementaties van de gekozen algoritmes wordenworden gegeven in appendix C, evenals van de meer voor de hand liggende veelterm-functionaliteiten die hier niet besproken worden.

Een afweging tussen snelheid en compactheid dient zich aan voor de hardware-implementatie van de veeltermoperaties. De sleutelgeneratie is normaliter niettijdskritisch, zoals vermeld in sectie 2.3.1. De decryptie wordt volledig gedomineerdqua snelheid door drie stappen waarvan er twee veeltermfuncties zijn: de opbouw vansyndroomveelterm Syn(z) en het zoeken van de nulpunten van foutlocatieveeltermσ(z). Oplossingen worden gezocht voor de twee voorgaande performantie-pijnpunten;voor alle andere bouwblokken is oppervlakte veel belangrijker dan snelheid.

Het zoeken van nulpunten wordt onderworpen aan een uitgebreide algoritme-exploratie in secties 6.1 en 6.5. Een specifiek bouwblok voor het inverteren van lineaireveeltermen wordt voorgesteld in sectie 6.2. Het meer algemene Euclides-algoritme isnog steeds vereist voor andere stappen van Patterson’s algoritme, maar kan nu vollediggerelaxeerd worden. In sectie 6.4 worden de kwadratuur- en vierkantsworteloperatiesimultaan behandeld.

6.1 Veeltermevaluatie

Meervoudige veeltermevaluaties zijn vereist in drie stappen van het McEliece-algoritme. Goppa generatorveelterm g(z) wordt geëvalueerd voor alle elementen vanhet eindig veld bij het opstellen van pariteitscontrolerende matrix H (zie sectie 2.2.2).In sectie 6.2 wordt aangetoond dat men syndroomveelterm Syn(z) eveneens kan

47

6. Veeltermalgoritmes

berekenen via een meervoudige evaluatie van g(z). Verder is een exhaustieve veelter-mevaluatie bruikbaar om de nulpunten van foutlocatieveelterm σ(z) te detecteren.Zowel g(z) als σ(z) hebben graad t en worden vervangen door de generieke veelterm

p(z) = ptzt + pt−1z

t−1 + . . .+ p1z + p0.

Drie algoritmes worden besproken en vergeleken: het Hornerschema, het algoritmevan Chien en een modificatie van het Chien-algoritme. De complexiteit van dezemethodes wordt uitgedrukt in termen van CADD, CMUL en CEXP , de complexiteitenvan een eindig-veldoptelling, -vermenigvuldiging en -exponentiëring respectievelijk.De meest voor de hand liggende methode is een directe veeltermevaluatie en kan alsreferentie gebruikt worden. Deze heeft een relatief hoge complexiteit

C = tCADD + (2t− 1)CMUL,

indien de exponenten stapsgewijs berekend worden via een lopend product. Demogelijkheden tot parallellisme zijn enigszins beperkt vermits elke vermenigvuldigingberust op het resultaat van de voorgaande vermenigvuldiging.

6.1.1 Hornerschema

Bij het Hornerschema wordt de veelterm herschreven als

p(z) = ((. . . ((ptz + pt−1)z + pt− 2) + . . .)z + p1)z + p0.

De complexiteit is lager dan bij de directe veeltermevaluatie en bedraagt

C = tCADD + tCMUL.

Het Hornerschema is eveneens ongeschikt voor parallellisme vermits men een se-quentiële ketting van vermenigvuldigingen en optellingen bekomt. Beide methodeshebben wel het voordeel dat de volgorde van evalueren arbitrair is.

6.1.2 Algoritme van Chien

Bij het algoritme van Chien [9] wordt de volgorde van de elementen bepaald door eengenerator element α van het eindig veld. Beschouw twee opeenvolgende elementena = αi en b = αi+1. Veronderstel dat alle termen van

p(a) = ptat + pt−1a

t−1 + . . .+ p1a+ p0

reeds berekend zijn. De termen van p(b) zijn gerelateerd tot deze van p(a) als volgt:

p(b) = αt(ptat) + αt−1(pt−1at−1) + . . .+ α(p1a) + p0.

Er wordt dus telkens met dezelfde set waarden {αt, αt−1, . . ., α, 1} vermenigvuldigd.De mogelijkheden tot parallellisme zijn groter dan bij het Hornerschema: allevermenigvuldigingen zijn volledig onafhankelijk. Bemerk dat de t vermenigvuldigers

48

6.1. Veeltermevaluatie

in een volledig uitgerolde versie sterk vereenvoudigd kunnen worden vermits één vande operanden een constante is. De complexiteit per evaluatie wijzigt niet:

C = tCADD + tCMUL.

Het element α = x is een uitstekende keuze als generator. De opeenvolgende machtenvan α laten zich dan zeer efficiënt berekenen (zie sectie 5.4). De evaluatie startmen best bij het element: α0 = 1. De termen van p(1) zijn immers gelijk aan decoëfficiënten van p(z). Het nulelement is geen macht van α en moet afzonderlijkbeschouwd worden: de evaluatie laat zich echter reduceren tot p(0) = p0.

6.1.3 Modificatie van het Chien algoritme

Een modificatie van het Chien algoritme wordt beschreven in [20]. Elke veeltermkan ontbonden worden als een som van veelvouden van affiene veeltermen

Ai(z) = a0 + Li(z) met Li(z) =∑j=1

ajz2j.

Zo kan p(z) bijvoorbeeld ontbonden worden als

p(z) = p3z3 +A0(z) + z5A1(z) + z10A2(z) + . . .+ z25A5(z),

met A0(z) = p0 + p1z + p2z

2 + p4z4 + p8z

8

A1(z) = p5 + p6z + p7z2 + p9z

4 + p13z8

...A5(z) = p25 + p26z + p27z

2.

De elementen worden geordend volgens een Gray code: de veeltermvoorstellingvan twee opeenvolgende elementen a en b = a+ ∆j verschilt hoogstens in één bit.Hierbij is ∆j = xj , met j ∈ [0, d − 1] het eindig-veldelement dat de verschilbitaanduidt. Veronderstel dat affiene veeltermen Ai reeds berekend zijn voor a. Deaffiene veeltermen geëvalueerd voor b relateren zich tot deze voor a als volgt:

Ai(b) = Ai(a) + Li(∆j).

De waarden Li(∆0), Li(∆1), . . . , Li(∆d−1) worden getabelleerd. De complexiteit voorde eerder vermelde ontbinding reduceert zich tot

C = dd t+ 15 e(4CMUL + 3CADD) + (n− 1)(d t+ 1

5 e(CMUL + 2CADD) + 2CEXP )

6.1.4 Besluit

Tabel 6.1 resumeert de drie besproken algoritmes; de complexiteiten worden vergelekenvoor een exhaustieve evaluatie van alle eindig-veldelementen. Voor niet-exhaustieveveeltermevaluaties is het Hornerschema de enige optie. Voor een exhaustieve evaluatie(bijvoorbeeld het zoeken van nulpunten), geniet het originele Chien algoritme een

49


duidelijke voorkeur boven de modificatie ervan omwille van vier redenen. Eerstis er het exponentiëren van eindig-veldelementen, een gecompliceerde bewerkingindien men in een veeltermbasis rekent. Verder pleiten de betere mogelijkheden totparallellisme enerzijds en minder logica en geheugen anderzijds eveneens voor hetoriginele algoritme.

Hornerschema algoritme van Chien Chien modificatie# ADD nt (n− 1)t d t+1

5 e(2(n− 1) + 3d)n = 2048, t = 27 55.296 55.269 24.762# MUL nt (n− 1)t d t+1

5 e(n− 1 + 4d)n = 2048, t = 27 55.296 55.269 12.546# EXP 0 0 d t+1

5 e(2(n− 1))n = 2048, t = 27 0 0 24.564Volgorde / Generator α Gray codeParallellisme − + 0Hardware complexiteit + + −Geheugen (bits) d (t+ 1)d (t+ 1)d+ d t+1

5 ed2

n = 2048, t = 27 11 308 1034

Tabel 6.1: Exhaustieve veeltermevaluatie.

6.2 Inversie van een lineaire veelterm

De opbouw van syndroomveelterm Syn(z) vereist de inversie van gemiddeld n/2 =1024 lineaire veeltermen per decryptie. De eenvoudige vorm van zo’n lineaire veeltermz+a laat een zeer efficiënte inversie toe, in vergelijking met het uitgebreide algoritmevan Euclides. Men zoekt de veelterm c(z) = ct−1z

t−1 + ct−2zt−2 + . . . + c1z + c0

waarvoor geldt:

c(z)(z + a) = 1 mod g(z).

Aangezien g(z) monisch is, herleidt de reducerende veelterm van de vermenigvuldigingzich tot ct−1g(z). Bovenstaande vergelijking levert dan een stelsel met t vergelijkingenen evenveel onbekenden op:

a g01 a g1

1 a g2. . . . . . ...

1 a gt−31 a gt−2

1 gt−1 + a

c0c1c2...

ct−3ct−2ct−1

=

100...000

.

50

6.3. Algoritme van Euclides

De oplossing van het stelsel kan in een zeer aantrekkelijke vorm geschreven worden:

c0 = ct−1g1 + ac1c1 = ct−1g2 + ac2

...ct−3 = ct−1gt−2 + act−2ct−2 = ct−1gt−1 + act−1ct−1 = 1

g(a) .

Algoritme 6.1 resumeert hoe de coëfficiënten bij de inversie van een lineaire veeltermberekend worden volgens aflopende graad. Met aanwending van het Hornerschemavoor de veelterm-evaluatie g(a), bedraagt de totale complexiteit:

C = (2t− 1)CADD + (3t− 2)CMUL + CINV .

Algoritme 6.1 Inversie van een lineaire veelterm z + a

In: eindig-veldelement aIn: monische irreduceerbare veelterm g(z) van graad tUit: inverse veelterm c = 1/(z + a) van graad t− 1ct−1 ← 1

g(a)for i = t− 2 to 0 doci ← ct−1gi+1 + aci+1

end for

6.3 Algoritme van EuclidesHet algoritme van Euclides is toepasbaar op veeltermen over een eindig veld metirreduceerbare veelterm g(z). Voor een zeker paar veeltermen p1(z) en p2(z), berekenthet algoritme de grootste gemende deler gcd(z). Het standaard algoritme is eerderbeperkt, maar het uitgebreide algoritme ondersteunt meerdere stappen van McEliece.De Ben-Or procedure controleert of de graad van een grootste gemene deler al dan nietéén overschrijdt. Verder vereist elke decryptie-cyclus de berekening van de syndroominverse T (z) = Syn(z)−1 en het oplossen van de vergelijking a(z) = b(z)R(z).

Eerst wordt het uitgebreide algoritme in zijn oorspronkelijke vorm besproken.Een variant reduceert de complexiteit in ruil tegen een verlies aan flexibiliteit. Detoepasbaarheid van beide algoritmes op McEliece wordt telkens besproken.

6.3.1 Het uitgebreide algoritme

Het uitgebreide algoritme van Euclides berekent niet alleen de grootste gemene delervan een paar veeltermen p1(z) en p2(z), maar ook een u(z) en v(z) waarvoor deBézout stelling geldt:

u(z)p1(z) + v(z)p2(z) = gcd(z) mod g(z).

51


Bovenstaande vergelijking is tevens de lus-invariant van het algoritme. Bemerkdat u(z), v(z) en gcd(z) slechts tot op een constante factor na bepaald zijn. Hetuitgebreide algoritme steunt op het delen van veeltermen, waarbij zowel het quotiëntals de rest vereist zijn. Een deling is echter een zeer gecompliceerd in hardware, zekerindien de operanden veeltermen over een eindig veld zijn.

Een meervoudige berekening van een grootste gemene deler gcd(z) volstaat voorde Ben-Or procedure. De berekening van inverse T (z) = Syn(z)−1 is mogelijk indienmen p1(z) = Syn(z) en p2(z) = g(z) kiest. De Bézout vergelijking reduceert zichdan tot

u(z)Syn(z) = gcd(z) mod g(z).

De inverse T (z) bekomt men uiteindelijk door normalisatie:

T (z) = u(z)/gcd0.

Het oplossen van de veeltermvergelijking a(z) = b(z)R(z) gebeurt met p1(z) = R(z)en p2(z) = g(z) als invoer. Een flexibel stopcriterium wacht tot de gewenste gradenvan b(z) = u(z) en a(z) = gcd(z) bereikt zijn.

6.3.2 Variant op het uitgebreide algoritme

Algoritme 6.2 Variant van het uitgebreide algoritme van EuclidesIn: irreduceerbare veelterm g(z)In: veelterm p(z)Uit: veelterm y(z)Uit: veelterm v(z)x(z)← g(z)y(z)← p(z)u(z)← 0v(z)← 1degx← degree(x(z))degy ← degree(y(z))while degy > degstop doif degx < degy thenverwissel x(z) en y(z)verwissel degx en degyverwissel u(z) en v(z)

end ifδ ← degx− degyd← xdegx/ydegyx(z)← x(z) + dzδy(z)u(z)← u(z) + dzδv(z)degx← degreex(z)

end while

52

6.4. Kwadraat en vierkantswortel

Verscheidene varianten vermeiden een gecompliceerde staartdeling en berekenende inverse op een alternatieve manier [37]. Het resultaat voldoet niet meer aande stelling van Bézout. Algoritme 6.2 is een veralgemening van algoritme 5.1; deingaande veeltermen worden gereduceerd met behulp van een optelling. De meestsignificante term van x(z) wordt in elke iteratie nul gemaakt door sommatie met eenverschoven en geschaalde versie van y(z). De graad van x(z) blijft stelselmatig dalen.Wanneer ze lager wordt dan de graad van y(z), volgt er een wissel. De lus-invariantenzijn als volgt: {

y(z) = v(z)p(z) mod g(z)x(z) = u(z)p(z) mod g(z) .

Voor de berekening van inverse T (z) = Syn(z)−1 kiest men p(z) = Syn(z), metdeg_stop = 0 als stopcriterium. Normalisatie levert het gewenste resultaat:

T (z) = v(z)/y0.

Het oplossen van de veeltermvergelijking a(z) = b(z)R(z) gebeurt met p(z) = R(z) alsinvoer. Het flexibel stopcriterium bepaalt opnieuw de gewenste graden van b(z) = v(z)en a(z) = y(z). De berekening van een grootste gemene deler is daarentegen nietmeer mogelijk. De Ben-Or procedure hoeft echter enkel te weten of de graad van eengrootste gemene deler al dan niet nul overschrijdt, waarbij één van de operandentelkens g(z) is. Een inverteerbaarheidstest, die inherent aanwezig is bij deze variante,is equivalent: resultante y(z) moet een constante zijn.

6.4 Kwadraat en vierkantswortel

De berekening van een vierkantswortel is éénmaal vereist in Patterson’s algoritme.Een implementatie van de kwadratuuroperatie is enkel nodig indien men de sleutel-generatie en dus ook de Ben-Or procedure in hardware uitvoert. Beide bewerkingenworden simultaan besproken voor een generieke veelterm p(z) met graad t− 1. Hetkwadraat van p(z) berekent men best niet als een algemene vermenigvuldiging: zowelde coëfficiëntsgewijze vermenigvuldigingen als de daaropvolgende reductie modulog(z) zijn kostelijke bewerkingen. De vierkantswortel is via kleine stelling van Fermatte herleiden tot een meervoudige vermenigvuldiging

√p(z) = (p(z))2td−1 , die men kan

berekenen in td−1 = 296 stappen via herhaaldelijk kwadratering. Een veralgemeningvan de matrix-gebaseerde methode uit sectie 5.5 is echter veel efficiënter voor beideoperaties en in het bijzonder voor het berekenen van een vierkantswortel.

6.4.1 Matrix-gebaseerde berekening

Veeltermen worden voorgesteld als vectoren van eindig-veldelementen:

p(z) = p0 + p1z + . . .+ pt−2zt−2 + pt−1z

t−1 =(p0 p1 . . . pt−2 pt−1

)53


Men zoekt de t× t matrix M van eindig-veldelementen waarvoor geldt dat:(1 z2 . . . z2(t−2) z2(t−1)

)=(

1 z . . . zt−2 zt−1)M mod g(z).

Kolom i ∈ [0, t − 1] van matrix MT correspondeert met de veelterm z2i. Kolomi van matrix M−T correspondeert met de veelterm

√zi. Het kwadraat en een

vierkantswortel van een veelterm p(z) kan men hiermee berekenen als volgt: p2(z) =(p2

0 p21 . . . p2

t−2 p2t−1

)MT mod f(x)√

p(z) =( √

p0√p1 . . .

√pt−2

√pt−1

)M−T mod f(x)

De opslag vanMT enM−T tabellen vereist echter een geheugen van 2mt2 = 1603 bits(of eventueel iets minder indien men rekening houdt met de spaarse kolommen). Eeniteratieve berekening die equivalent is met de matrix-methode vermijdt de explicieteopslag.

6.4.2 Iteratieve berekening

De uitdrukkingen voor het kwadraat en de vierkantswortel kunnen herschrevenworden als volgt [31]:{

p2(z) =∑t−1i=0 r

2i z

2i mod g(z)√p(z) =

∑t−1i=0√ri√zi mod g(z)

De eerste dt/2e machten van z in de expressie p2(z) vereisen geen reductie modulog(z). De daaropvolgende machten worden recursief berekend met schuif- en modulo-operaties. Bij de vierkantswortel

√p(z) zijn de even machten van z meteen gekend.

De oneven machten worden iteratief berekend via een relatief eenvoudige relatie:√zi = z

√zi−2, met i ≥ 3. Het probleem herleidt zich bijgevolg tot het vinden van√

z. Bij vooraf berekende sleutels, is het aangewezen om√z te tabelleren.

6.4.3 Vierkantswortel√

z

Aangezien de vierkantswortel√z op voorhand berekend wordt, kan men nu wel

herhaaldelijk kwadrateren. Een efficiëntere methode wordt eveneens beschreven in[31]. Eerst wordt de irreduceerbare veelterm g(z) ontbonden in twee veeltermen g0(z)en g1(z) zodat g(z) = g2

0(z) + zg21(z). Voor t = 27 bekomt men:

g0(z) = √g26z13 +√g24z

12 + . . .+√g2z +√g0 ,

g1(z) = √g27z13 +√g25z

12 + . . .+√g3z +√g1 .

Men bepaalt twee veeltermen v0(z) en v1(z) waarvoor geldt dat 1 = v0(z)g1(z) +v1(z)g0(z). Men kan vervolgens bewijzen dat:

√z = v0(z)g0(z) + zv1(z)g1(z).

Als men de graad van v0(z) en v1(z) beperkt tot 13 en 12 respectievelijk, vereisen dezelaatste vermenigvuldigingen geen reductie modulo g(z). Het uitgebreide algoritmevan Euclides kan hiervoor zorgen.

54

6.5. Nulpunten

6.5 Nulpunten

Wegens de hoge graad van de foutlocatieveelterm σ(z) zijn directe methodes onbruik-baar voor het zoeken van nulpunten. Een exhaustieve evaluatie van σ(z) voor allen = 2048 elementen van het eindig veld werd reeds besproken in sectie 6.1. Hetalgoritme van Chien bleek zeer geschikt voor een hardware-implementatie en laattevens de introductie van parallellisme toe. Alternatieven worden besproken in devolgende paragrafen.

Elke methode die een veelterm kan factoriseren in een product van irreduceerbareveeltermen, is inherent ook bruikbaar voor het zoeken van nulpunten. De foutlo-catieveelterm σ(z) kan normaliter gesplitst worden in t = 27 factoren, allemaaluniek en van een lineaire graad. De factorisatiemethodes worden gekenmerkt dooreen lage complexiteit in termen van de eindig-veldoperaties in vergelijking met deexhaustieve-evaluatiemethodes. Methodes zoals het Berlekamp Trace algoritme enhet gelijke graad factorisatiealgoritme van Cantor en Zassenhaus [56] lenen zichuitstekend tot een software-implementatie.

Een veelvuldigheid aan gecompliceerde veeltermbewerkingen (bijvoorbeeld delingen kwadratering) maken hardware-implementaties echter zeer kostelijk. Een aantalvan deze veeltermbewerkingen kunnen gedeeld worden met andere stappen vanhet Patterson-algoritme of met een eventuele hardware-sleutelgeneratie, maar ditverandert weinig aan voorgaande conclusie. De bewerkingen die gedeeld kunnenworden zijn namelijk allemaal gerelateerd tot niet-tijdskritische algoritmestappen. Defactorisatiemethodes vereisen echter een veelvuldige uitvoering van deze bewerkingen,waardoor ze juist wel tijdskritisch worden.

Het veralgemeende Goertzel algoritme biedt eveneens een lagere complexiteitdan de exhaustieve-evaluatiemethodes [8]. Er moeten minder veeltermbewerkingenvoorzien worden dan bij de factorisatiemethodes: een herhaalde staartdeling van σ(z)met een daaropvolgende veeltermevaluatie van de rest volstaan. Voor de gegevenparameterwaarden zijn er echter 187 veeltermdelingen vereist en moet er circa 25Kbit aan getabelleerde waarden voorzien worden.

Een exhaustieve veeltermevaluatie met het Chien-algoritme blijft de eerste keuzevoor de parameterwaarden {n = 2048, t = 27} vanwege de lage hardwarekost. Indienmen een zeer snelle decryptie wenst, is het wellicht nog goedkoper om het algoritmevan Chien te parallelliseren dan om één van de meer gecompliceerde methodes aante wenden.

6.6 Besluit

Algoritmes voor de vereiste veeltermoperaties werden geëxploreerd. De twee veelterm-gerelateerde performantie-pijnpunten van de decryptie kregen extra aandacht. Hetinverteren van een lineaire veelterm reduceert zich tot één veeltermevaluatie, gevolgddoor één inversie van een eindig-veldelement en het t− 1 maal doorlopen van een re-latief eenvoudige lus. Het meer algemene Euclides-algoritme is nog steeds vereist voortwee stappen van Patterson’s algoritme, maar kan nu volledig geoptimaliseerd wor-

55


den naar een minimale hardware-oppervlakte. De exhaustieve-evaluatiemethode vanChien zoekt de nulpunten van foutlocatieveelterm σ(z): een eenvoudige architectuurmet een flexibele snelheid-oppervlakte balancering wordt aldus bekomen.

56

Hoofdstuk 7

Resultaten en toepassingen

Eerst worden de resultaten van de XC3S1400AN-5 FPGA- en de 0, 13µm standard cellASIC-synthese getabelleerd en besproken. De vergelijking met de MicroEliece FPGA-implementatie [16], tot dusver te enige referentie, wordt gemaakt. In deze thesis werder gekozen voor een middenweg tussen snelheid en compactheid, de klassieke afwegingbij een digitaal ontwerp. Een bespreking van de schaalbaarheid van het ontwerp (intwee richtingen) dient zich aan. Vervolgens worden de bekomen FPGA-resultatenvergeleken met deze van andere publieke sleutel algoritmes. Tenslotte wordt detoepasbaarheid van het eigen ontwerp voor digitale handtekeningen besproken.

7.1 FPGA- en ASIC-syntheseTabel 7.1 contrasteert het aantal klokcycli per algoritmestap van de eigen imple-mentatie met deze van de MicroEliece-paper. De getabelleerde waarden voor deeigen implementatie corresponderen met de testvectoren gegeven in appendix A. Hettotaal aantal klokcycli wordt gereduceerd met circa een factor 18.

Stap Eigen werk MicroElieceSyn(z) =

∑ri/(z + aπ(i)) 30.274 360.184

T (z) = Syn−1(z) mod g(z) 1.821 625R(z) =

√T (z) + z mod g(z) 626 487

a(z) = b(z)R(z) mod g(z) 960 312σ(z) = a2(z) + zb2(z) 1.216 312.328σ(z) = {rooti} 57.356m = m+

∑(PRNG(rooti)) / m = m′S−1 1.996 1.035.684

totaal 94.249 1.709.620

Tabel 7.1: Klokcycli-verdeling voor zowel de eigen implementatie als de MicroEliece-implementatie.

De drie performantie-pijnpunten van de MicroEliece-decryptie werden aangepakt.De neutralisatie van scramblingmatrix S gebeurt quasi helemaal in parallel metPatterson’s algoritme dat de twee andere pijnpunten omvat. De TRIVIUM-PRNG

57

7. Resultaten en toepassingen

die de rijen van S−1 genereert, is met 32 bits per klokcyclus nog iets te grootgedimensioneerd. De eerste neutralisatie-fase vereist namelijk 80053 klokcycli terwijlPatterson’s algoritme er 92253 nodig heeft. De bijkomende oppervlakte hierdoor is ergbeperkt vermits stroomcijfers schaalvoordelen hebben (zie sectie 4.1.3). Het algoritmevan Chien in combinatie met de alternatieve strategie voor de eindig-veldbewerkingenlevert resultaat. Idem dito voor de opbouw van de syndroomveelterm Syn(z),waarvoor er een bouwblok specifiek voor het inverteren van lineaire veeltermen werdontworpen. De niet-tijdskritische stappen daarentegen zijn iets trager als deze vanMicroEliece-implementatie vermits de betreffende bouwblokken naar een minimaleoppervlakte geoptimaliseerd werden. De relaxering van de Euclides-bouwblok iscruciaal hierbij: deze ligt aan de basis van een grote oppervlakte-reductie.

BouwblokXC3S1400AN-5 FPGA ASIC

Slices LUT- FF- RAM- fmax GEslices slices blokken (Mhz)POLY_ACCUMUL 67 67 67 0 287 2294POLY_BENCH 101 112 83 0 171 2438POLY_QUEUE 74 80 72 0 177 2348POLY_TURN 166 312 315 0 289 2699POLY_MUL 242 307 157 0 128 5513POLY_SQRT 377 424 234 0 157 6576POLY_SQRTEO 113 100 98 0 195 2336POLY_EUCLID 905 1119 435 0 90 12567POLY_INVZA 337 475 114 0 109 2528POLY_CHIEN 174 227 109 0 173 3034REG_G 22 36 11 0 403 163REG_SQRTZ 23 37 11 0 293 165CODEWORD_TEST 206 298 80 0 147 1321RAM_P_SHELL 6 0 11 2 838 1TRIVIUM_PRNG 234 462 294 0 276 3409PRNG2SINV 10 20 7 0 299 80DECODER7TO128 80 144 0 0 / 169MESSAGE_ACCUMUL 61 97 29 2 253 279PICOBLAZE ≈ 100 ≈ 200 ≈ 200 1 ≈ 125 ≈ 500TOPCELL 2873 4678 2294 2 92 47261Correctie 106 200 211 3 0 501Totaal 2979 4878 2505 5 92 47762Utilisatie 26, 4% 21, 7% 11, 1% 15, 6% / /MicroEliece totaal 11218 22034 8977 20 85 /MicroEliece utilisatie 99, 6% 97, 8% 40% 62, 5% / /Beschikbaar 11264 22528 22528 32 / /

Tabel 7.2: FPGA- en ASIC-synthese van de McEliece-decryptie.

In tabel 7.2 worden de resultaten van de ASIC- en FPGA-synthese geresumeerd.

58

7.1. FPGA- en ASIC-synthese

De bouwblokken maken allemaal deel uit van de zogenaamde topcell, maar werdeneerst afzonderlijk gesynthetiseerd. De veeltermbouwblokken (zie appendix C voorde GEZEL-code) vormen een duidelijk afgelijnde categorie hierin. GEZEL-code van devoornaamste resterende bouwblokken, TRIVIUM_PRNG en MESSAGE_ACCUMUL,wordt gegeven in appendix D. De PicoBlaze kon niet gesynthetiseerd worden: degetabelleerde waarden zijn schattingen.

De synthese van de topcell is niet zomaar een samenraapsel van de onderliggendebouwblokken: optimalisatie tussen deze bouwblokken onderling is aanwezig. Inef-ficiënties zoals equivalente flip-flops en niet gebruikte signalen worden weggewerkt.Een tweeledige correctie op de topcell-resultaten werd uitgevoerd om de vergelijkingmet de MicroEliece-synthese meer accuraat te maken. Enerzijds zorgt een bypassvan de permutatie-bouwblok RAM_P_SHELL in de GEZEL-code ervoor dat wordtweg-geoptimaliseerd. Deze bypass is enkel aanwezig voor simulatie-redenen en heeftnormaliter geen invloed op het aantal klokcycli van tabel 7.1. Anderzijds moetde niet-gesynthetiseerde PicoBlaze er eveneens bij. Verdere correcties kunnen eve-neens overwogen worden: de bouwblok CODEWORD_TEST die de getabelleerder′-testvector van appendix A bevat, wordt in de praktijk vervangen door een in-gangsbuffer. De MicroEliece-implementatie bevat ook nog een beperkte hoeveelheidUART-interfacelogica die niet aanwezig is bij de eigen implementatie.

De totale snelheid van de McEliece-decryptie wordt niet alleen bepaald door hettotaal aantal klokcycli, maar ook door de maximale klokfrequentie fmax (voor deFPGA-synthese). Een stelselmatige verkorting van het kritische pad werd aangevat:er ontstond een terugkoppeling tussen de GEZEL-code enerzijds en de Xilinx DesignSuite anderzijds. Wegens het beperkte tijdskader werd er gestopt bij een maximaleklokfrequentie van 92 Mhz. Deze is dus niet veel hoger dan de 85 Mhz van MicroEliece-implementatie.

Er is echter nog een groot potentieel aanwezig om het kritisch pad verder teoptimaliseren. De Euclides-bouwblok POLY_EUCLID is tot dusver de limiterendefactor. Een verkorting van het bijhorende kritische pad heeft amper effect op detotale performantie, maar vereist wel een herontwerp van de meest gecompliceerdetiming van alle veeltermbouwblokken. Dat is meteen ook de reden waarom erdaar juist gestopt werd. De inversie van eindig-veldelementen (aanwezig in zowelPOLY_EUCLID als POLY_INVZA) vormt wellicht het volgende kritische pad in derij: het verkorten van dit pad is wel relatief eenvoudig en heeft eveneens geen nefastegevolgen voor de performantie.

Het vereiste RAM-geheugen wordt gereduceerd met een factor vier. De ex-acte allocatie van de RAM-blokken in de MicroEliece-implementatie wordt niettoegelicht in de bijhorende paper. De afwezigheid van meerdere conversietabellentussen de veeltermbasis en de exponentiële basis, is in ieder geval de voornaamsteoorzaak van de reductie. Mogelijk wordt een beperkt aantal RAM-blokken in deMicroEliece-implementatie gebruikt voor het bufferen van in- en uitgaande data, watniet gedaan wordt bij de eigen implementatie. Een eventuele correctie van één oftwee bijkomende RAM-blokken ter buffering van ingaande data volstaat. Uitgaandebuffering kan namelijk vervat worden in de reeds aanwezige RAM-blokken van deMESSAGE_ACCUMUL bouwblok die tot dusver een heel lage utilisatie hebben.

59


7.2 Schaalbaarheid

Het ontwerp vormt een middenweg tussen hoge-snelheidtoepassingen zoals serversenerzijds en lage-snelheidtoepassingen zoals RFID-tags anderzijds. Een schaling vanhet ontwerp in beide richtingen wordt besproken.

7.2.1 Schaling richting servertoepassingen

Drie stappen van de McEliece-decryptie werden als tijdskritisch geïdentificeerd: eenversnelling van de globale decryptie beperkt zich dan ook tot deze drie stappen. Zeworden achtereenvolgens toegelicht.

Bij de opbouw van syndroomveelterm Syn(z) via lineaire-veelterminversie zijn erweinig of geen schaalvoordelen aanwezig. Zowel het aangewende Horner-schema alsde lus die de uitgangscoëfficiënten produceert zijn niet geschikt voor een efficiënteparallellisatie.

Het algoritme van Chien daarentegen biedt veel betere mogelijkheden in ditverband. In het uiterste geval kan de bouwblok één veeltermevaluatie per klokcyclusuitvoeren om aldus de nulpunten te vinden in n = 2048 klokcycli. De t = 27 vereistevermenigvuldigers hiervoor kunnen relatief compact gerealiseerd worden vermits éénvan de operanden telkens een constante xi is.

Tenslotte is er nog de neutralisatie van scramblingmatrix S, die bij voorkeurvolledig in parallel gebeurt met de twee voorgaande performantie-pijnpunten. Hetis dus aangeraden om de snelheid van de drie pijnpunten volledig op elkaar af testemmen. De aangewende TRIVIUM-PRNG produceert 32 bits per klokcyclus enkan verder versneld worden tot 70 bits per klokcyclus zonder het bijhorende kritischepad te verhogen. De schaalvoordelen van hoge-doorvoer stroomcijfers zijn nog steedsvan toepassing hierbij. Meerdere TRIVIUM-PRNG’s behoren uiteraard ook tot demogelijkheden. Bemerk dat de expliciete opslag van S−1 in RAM-geheugen veelaleen beter alternatief vormt indien zeer hoge snelheden gewenst zijn.

Hoge-snelheidtoepassingen kunnen baat hebben bij een volledige hardware-sleutelgeneratie. De vereiste algoritme-exploratie voor deze uitbreiding werd reedsuitgevoerd in hoofdstuk 4.

7.2.2 Schaling richting RFID-tags

De bekomen resultaten kunnen niet bevestigen of lichtgewicht cryptografietoepas-singen al dan niet binnen de mogelijkheden van McEliece liggen: verder onderzoekkan uitsluitsel bieden. Geheugen, oppervlakte en energie zijn erg schaars bij der-gelijke toepassingen; snelheid en flexibiliteit betalen hiervoor steevast de tol. Eenontwerpstrategie die deze eisen nastreeft, wordt besproken.

De tien afzonderlijke veeltermbouwblokken kunnen vervangen worden door éénenkele universele veeltermbouwblok die alle operaties verenigt. Deze bevat intern vierveeltermen van graad t, het absolute minimum zoals opgelegd door het uitgebreidealgoritme van Euclides. De veeltermen-coëfficiënten zijn niet meer toegankelijk viaeen FIFO-gebaseerde methode wegens het hoge dynamische vermogen, maar via een

60

7.3. Vergelijking met andere publieke sleutel systemen

multiplexer-gebaseerde methode (zie sectie C.1). Een low leakage CMOS-technologiebeperkt het statische vermogen.

Ook de eindig-veldbouwblokken van hoofdstuk 5 worden slechts éénmaal gere-aliseerd binnen de universele veeltermbouwblok. De eindig-veldinversie kan menreduceren tot een meervoudige vermenigvuldiging. De functionaliteit van een kwa-dratuurbouwblok zit reeds vervat in een algemene vermenigvuldiging en kan menbijgevolg weglaten. De FSM die de gecompliceerde interactie tussen de veeltermre-gisters enerzijds en de eindig-veldbouwblokken anderzijds coördineert, wordt hardgecodeerd in hardware. Er wordt dus afgestapt van hardware-software co-design.

Voor een lage-doorvoer PRNG zijn stroomcijfers, blokcijfers en hashfuncties zeerconcurrentieel, zoals aangetoond in tabel 4.2. Het loont wellicht de moeite om eenmeer uitgebreide vergelijking te maken.

7.3 Vergelijking met andere publieke sleutel systemenIn tabel 7.3 worden de performantie en de compactheid van zowel de eigen als deMicroEliece McEliece-implementatie gecontrasteerd met deze van de publieke sleutelalgoritmes besproken in sectie 2.6. De getabelleerde implementaties hebben eenvergelijkbaar veiligheidsniveau van circa 80 bit. De compactheid wordt vergelekenop twee vlakken: enerzijds de hoeveelheid logica en anderzijds het vereiste geheugen.De snelheid wordt op vier vlakken vergeleken. Het aantal klokcycli en de maximaleklokfrequentie fmax voor één enkele encryptie of decryptie, vormen samen de uit-voeringstijd. De doorvoer van nuttige informatiebits vormt wellicht nog een beteremaatstaf vermits deze ook nog de klaartekstlengte in rekening brengt.

Algoritme FPGA Slices RAM Cycli fmax Tijd Doorvoer(kbit) (MHz) (ms) (bit/s)

McElieceencryptie [16] Spartan-3AN 668 3640 162k 150 2, 24 780kdecryptie [16] Spartan-3AN 11.218 360 1, 7M 85 21, 61 81, 02keigen decryptie Spartan-3AN 2.979 90 94k 92 1, 1 1, 58MRSA-1024 [28] Spartan-3E 1.813 18 6, 5M 128 50, 5 20, 275kECC P-160 [24] Spartan-3 ? ? ? ? 5, 1 31, 2kNTRUencryptie [2] Virtex 6.373 0? 259 50 0, 005 48, 52M

Tabel 7.3: FPGA-implementaties van verschillende publieke sleutel cryptosystemen.

Het McEliece-algoritme blijkt veel sneller dan referentie-algoritmes RSA alsECC. Voor NTRU worden enkel resultaten voor de encryptie getabelleerd; dezevoor de decryptie kunnen echter als gelijkaardig beschouwd worden. Indien zowel deeigen decryptie als de encryptie van de MicroEliece-implementatie aan een schalingonderworpen worden, kunnen ze wellicht dezelfde performantie van NTRU behalen.Het vereiste geheugen voor zowel de encryptie als de decryptie is echter veel hoger danbij NTRU. Voor zeer compacte omgevingen lijkt NTRU over veel betere eigenschappen

61


te bezitten: verder onderzoek in dit verband kan uitsluitsel bieden. Bemerk wel datMcEliece nog een aantal voordelen biedt ten opzichte van NTRU die niet vervatzitten in bovenstaande tabel (zie sectie 2.6).

7.4 Digitale handtekeningen

Allereerst worden de basisconcepten van digitale handtekeningen besproken. HetNiederreiter-cryptosysteem is een variant van McEliece met betere eigenschappenvoor dit toepassingsgebied [10]. We bespreken deze variant en maken tegelijk de ver-gelijking met het origineel: het meeste werk uit deze thesis blijkt opnieuw bruikbaar.Tenslotte wordt de aanwending van beide cryptosystemen voor digitale handteke-ningen toegelicht.

7.4.1 Basisconcepten

Vele publieke sleutel algoritmes kunnen zowel vertrouwelijke informatie beschermenals digitale handtekeningen vormen, meestal onder licht gewijzigde vormen. Beschouween informatieblok doc van de zender, te voorzien van een digitale handtekening. Eenunidirectionele hashfunctie hash() naar keuze converteert de te beveiligen informatienaar een hashwaarde hash(doc). Deze veel compactere voorstelling wordt gebruiktvoor zowel het produceren als verifiëren van handtekeningen.

Enkel de authentieke zender kan een geldige handtekening produceren op basisvan diens private sleutel. De gebruikte procedure hiervoor is doorgaans zeer gelijkaar-dig met de decryptie: de hashwaarde kan dus in zekere zin als cijfertekst beschouwdworden. Aldus bekomt men de handtekening die tezamen met het informatieblokverzonden wordt. De ontvanger berekent eveneens de hashwaarde van het toegekomeninformatieblok: hash(doc). Verificatie van de toegekomen handtekening met de pu-blieke sleutel van de zender is doorgaans zeer gelijkaardig met de encryptieprocedure.Het eindresultaat moet gelijk zijn aan de hashwaarde hash(doc).

7.4.2 Het Niederreiter-cryptosysteem

Zowel het McEliece- als het Niederreiter-cryptosysteem baseren zich op twee gerela-teerde [n, k] blokcodes met foutcorrigerende capaciteit t. Enerzijds is er een privateGoppa-code die gedefinieerd wordt door een generatorveelterm g(z). Anderzijds iser een getransformeerde code die in tegenstelling tot de Goppa-code geen efficiëntdecoderingsalgoritme heeft.

Tabel 7.4 vergelijkt beide cryptosystemen volgens het referentiekader van eenpublieke sleutel cryptosysteem. Het zijn respectievelijk generator- en pariteitscon-trolerende matrices die de hoofdrol opeisen. Bemerk dat beide matrices equivalentevoorstellingen zijn van een zekere lineaire blokcode. Men kan bewijzen dat beidealgoritmes equivalent zijn qua veiligheid voor dezelfde parameters n, k en t.

De kleinere dimensies van een pariteitscontrolerende matrix resulteren in eenaantal voordelen voor het Niederreiter-cryptosysteem. Zowel het verspreiden van depublieke sleutel matrix als de corresponderende matrix-vector vermenigvuldiging bij

62

7.4. Digitale handtekeningen

McEliece NiederreiterPrivate sleutel k × k S (n− k)× (n− k) S

k × n G (n− k)× n Hn× n P n× n P

Publieke sleutel k × n G (n− k)× n H

Encryptie 1× k m 1× n e1× n r = mG+ e (n− k)× 1 s = HeT

Decryptie 1× n r′ = rP−1 (n− k)× 1 s′ = S−1s1× n c′ = Patterson(r′) 1× n c′ met Hc′T = s′

1× k m′ met c′ = m′G 1× n e′ = Patterson(c′)1× k m = m′S−1 1× n e = e′P−1

Tabel 7.4: Vergelijking van McEliece en Niederreiter.

de encryptieprocedure gebeuren veel sneller. De scramblingmatrix van de lineairetransformatie heeft eveneens kleinere dimensies.

De klaartekst is niet meer een codeboodschap m, maar een foutvector metHamminggewicht t. Het Niederreiter-cryptosysteem is bijgevolg niet geschikt voorhet verwerken van grote stromen informatie. De spaarse structuur van de klaartekstimpliceert wel dat men deze zeer compact kan voorstellen, wat kleine digitalehandtekeningen kan opleveren. De cijfertekst is niet meer een codewoord met tfouten maar een syndroomvector s.

De vier stappen van de decryptie zijn quasi identiek aan deze van McEliece,maar worden wel in omgekeerde volgorde uitgevoerd. Wegens de sterke gelijkenistussen variant en origineel, kunnen bijna alle technieken beschreven in deze thesisgerecycleerd worden. De parallelle neutralisatie van de scrambling matrix vormt eenbelangrijke uitzondering hierop. Door de kleinere dimensies van deze scramblingmatrix, is een sequentiële neutralisatie echter minder dramatisch.

7.4.3 Digitale handtekeningen met Niederreiter

De productie- en verificatieprocedures voor digitale handtekeningen maken respec-tievelijk gebruik van de decryptie en encryptie in een ongewijzigde vorm. Bemerk dathandtekening en klaartekst bijgevolg dezelfde lengte hebben. Voor dezelfde parame-ters n, k en t resulteert het Niederreiter-cryptosysteem dan ook in veel compacterehandtekeningen.

Het decrypteren van een willekeurige hashwaarde (cijfertekst) is echter eenprobleem voor beide cryptosystemen. Bij McEliece verschilt de hashwaarde meestalmeer dan t bits van een geldig codewoord. Bij Niederreiter is de hashwaardeeen syndroom dat meestal correspondeert met meer dan t bitfouten. Digitalehandtekeningen zijn enkel produceerbaar via een iteratieve procedure [10]: mengenereert hashwaarden totdat er één decrypteerbaar is. De concatenatie van hetinformatieblok en een teller i vormt de invoer van de hashfunctie. De teller wordt

63


opgehoogd totdat de hashwaarde hash(doc||i) decrypteerbaar is. De uiteindelijkewaarde van i maakt deel uit van de handtekening.

De drie parameters bepalen naast de veiligheid, de productie- en de verificaties-nelheid van de handtekening ook het gemiddelde aantal iteraties. Indien menk = n −mt kiest, is de kans op succes enkel een functie van de foutcorrigerendecapaciteit: P (succes) = 1/t!. Bemerk dat een kleine t zich vertaalt naar een grote nen k voor een zeker veiligheidsniveau. De voorgestelde parameters n = 216 en t = 9resulteren in een handtekening van slechts 81 bits. Een revisie van de parameters iswenselijk vermits hun veiligheidsanalyse niet gebaseerd is op de meest recente aanval[3].

64

Hoofdstuk 8

Besluit

In deze thesis werd de hardware-efficiëntie van het post-kwantum veilige McEliece-algoritme onderzocht, een onderwerp waarover tot op heden zeer weinig gepubliceerdis. De enige bestaande hardware-implementatie (op een Spartan-3AN FPGA) vormdehet vertrekpunt voor het eigen ontwerp. De encryptie bleek een zeer eenvoudigeprocedure die een flexibele afweging tussen snelheid en compactheid toelaat. Er isgeen marge meer voor verdere optimalisatie, in tegenstelling tot de kostelijke entrage decryptie. Het zoeken naar oplossingen voor deze decryptie, is de voornaamstebijdrage van deze thesis. Testvectoren en sleutels werden gegenereerd met een C/C++referentie-implementatie.

Een pijnpunten-analyse van de bestaande hardware-decryptie toont aan waarde grootste inefficiënties zich bevinden. Enerzijds is er de snelheid die vollediggedomineerd wordt door drie algoritmestappen. Anderzijds is er de logica-oppervlaktedie volledig gedomineerd door één enkele bouwblok die 64% van de XC3S1400AN-5decryptie-FPGA opvult. Oplossingen hiervoor werden gezocht en gevonden: naasteen parallellisatie van de decryptieprocedure (op systeemniveau), werd er tevens eenuitgebreide algoritme-exploratie uitgevoerd van de benodigde functionaliteiten. Deresultaten bekomen in deze thesis overtreffen deze van de bestaande implementatieruimschoots. Het aantal klokcycli wordt gereduceerd met circa een factor 18. Hetaantal FPGA-slices en de hoeveelheid RAM-geheugen worden gereduceerd met circaeen factor 3, 7 en 4 respectievelijk. Verder wordt er flexibiliteit geïntroduceerd metbehulp van hardware-software co-design.

Met 47.762 NAND-poort Gate Equivalenten liggen lage-kosttoepassingen nogniet binnen de mogelijkheden. Een herontwerp waarbij flexibiliteit en snelheidsystematisch omgeruild worden, kan ongetwijfeld veel betere resultaten opleverenvoor dit domen. Verder onderzoek naar varianten van het McEliece-algoritme die desleutelmatrices reduceren, is eveneens essentieel in dit verband.

De snelheid van eigen decryptie en van de MicroEliece-encryptie zijn veel hogerdan deze van vergelijkbare RSA- en ECC-implementaties. Een verdere schaling in derichting van hoog-performante toepassingen behoort zeker nog tot de mogelijkheden.Het McEliece-algoritme lijkt erg geschikt voor toepassingen waarbij geheugen enlogica-oppervlakte iets minder cruciaal zijn.

65

8. Besluit

Tenslotte vermelden we nog enkele varianten van het oorspronkelijke McEliece-algoritme die het onderwerp kunnen zijn van verder werk. Allereerst zijn er de CCA2-veilige varianten die aangeraden zijn voor alle praktische toepassingen. Verder kande boodschapsexpansie verlaagd worden met de variant beschreven in [5]. Tenslotteis er nog de besproken Niederreiter-variant waarmee men digitale handtekeningenkan produceren en verifiëren.

66

Bĳlagen

67

Bĳlage A

Patterson-testvectoren

Beschouw een [n,k] Goppa code met foutcorrigerende capaciteit t. Testvectorenvoor Patterson’s decoderingsalgoritme worden gegeven, met n = 2048, k = 1751 ent = 27 als parameterwaarden. Ze werden gegenereerd met de C/C++ referentie-code. Het eindig veld wordt gedefinieerd door de binaire irreduceerbare veeltermf(x) = x11 + x2 + 1. We noteren de elementen van het eindig veld als een decimaalgetal dat correspondeert met een binaire voorstelling in de veelterm basis. Deveeltermen over het eindig veld worden gedefinieerd door de irreduceerbare veelterm

g(z) = z27 + 1566 z26 + 1543 z25 + 1803 z24 + 2030 z23 + 1137 z22

+ 1295 z21 + 1601 z20 + 146 z19 + 1826 z18 + 1292 z17 + 1690 z16

+ 1367 z15 + 1993 z14 + 128 z13 + 1676 z12 + 1708 z11 + 1052 z10

+ 154 z9 + 340 z8 + 146 z7 + 1125 z6 + 871 z5 + 296 z4

+ 359 z3 + 1566 z2 + 102 z + 1433

We decoderen een ontvangen codewoord r′ met t = 27 fouten. De volgorde van deelementen ai van het eindig veld wordt vastgelegd door een teller (ai = i).

r′ = 00100000100010010111011011011000111100011011010011100001000101001101111111001110011100100110010001110100010110010010110011110111111000110111100010101011110100110000000011100110000111100101001011000011001000010101101100001100011001010000000001000010110001010100100111000101110111100111010111000011000010110101001111011010001100011000101000000000110000110000000000100001111101101110000000110101000110111001111101100110100100011001000011110001011101010111010010000000111111010111101111001000111001001101110011010001110111101000011001000011111101101111001111100111000010111101100001001000100001110011110111001010010110001011100011001111001101001000000100110110010000101111100010010011111110110000110010100110

69

A. Patterson-testvectoren

000101001111101111100000101000001001001100001110001101111100000000110110111100010011110101000111000011010011001111011010101110100010110101010001100100101101100110010110111111011111000100011010001110101001000001110111111101001101101101001110001011110000011111110010011110010011111001001011000011101000010111111011110001100101010100100000010010010111010101000000100111101011110000010100100010100101110001110011010011000010011110110110111010011100110110011010001010100011100101001010010101110000101100001101100011000011010010100010101010001111101011011111110111001010100010111110100001110100011001001110001011001101011000110100001110000011001001101000010111100011010111110101110101111100100100101110101010111001100000101011000111111010011011010000011000010101001010101110001101100100101000101111100111101011110110100000110111011101110001111011000101000100011001001000100011001000011010100110010001111101000010101011010110101111110101110000000001111001111111110001001110111001011010110101011100100011000100001000111001011001110011101011110100011011001001010111000001011001010100110010011100101001110101000110001100111100100110100110110100000101100000101101101001101101000111101010111111100100001011000111111011011001011100110111110001101010010100001001000001100110011100001101110101000100000010101010110001011110000110100011000010011001010010110010.

Elke ‘1’ in het ontvangen codewoord heeft een bijdrage tot de syndroom veelterm.De eerste uit een lange reeks geïnverteerde lineaire veeltermen is

(z + 2)−1 = 578 z26 + 1110 z25 + 1047 z24 + 1258 z23 + 1884 z22 + 1497 z21

+171 z20 + 187 z19 + 114 z18 + 1040 z17 + 1535 z16 + 912 z15

+ 712 z14 + 1211 z13 + 199 z12 + 88 z11 + 267 z10 + 144 z9

+ 574 z8 + 759 z7 + 1258 z6 + 1932 z5 + 1497 z4 + 680 z3

+ 324 z2 + 602 z + 394.

De uiteindelijke syndroom veelterm is als volgt:

Syn(z) = 1178 z26 + 32 z25 + 1165 z24 + 326 z23 + 735 z22 + 1038 z21

+1744 z20 + 610 z19 + 1483 z18 + 158 z17 + 1494 z16 + 1935 z15

+ 643 z14 + 464 z13 + 1725 z12 + 730 z11 + 375 z10 + 1973 z9

70

+ 140 z8 + 1229 z7 + 1427 z6 + 1845 z5 + 1900 z4 + 1103 z3

+ 773 z2 + 142 z + 144.

De inverse van syndroom veelterm Syn(z) wordt dan

T (z) = 1326 z26 + 824 z25 + 1249 z24 + 1418 z23 + 1741 z22 + 410 z21

+1728 z20 + 1898 z19 + 103 z18 + 421 z17 + 1918 z16 + 1834 z15

+ 947 z14 + 1130 z13 + 1560 z12 + 1679 z11 + 1876 z10 + 1404 z9

+ 1567 z8 + 817 z7 + 1239 z6 + 1648 z5 + 1013 z4 + 1835 z3

+ 1243 z2 + 687 z + 2010.

Een berekening van de vierkantswortel R(z) =√T (z) + z resulteert in

R(z) = 1284 z26 + 357 z25 + 990 z24 + 1475 z23 + 1449 z22 + 1551 z21

+104 z20 + 971 z19 + 1541 z18 + 239 z17 + 902 z16 + 420 z15

+ 428 z14 + 202 z13 + 85 z12 + 1308 z11 + 1581 z10 + 1576 z9

+ 1357 z8 + 1559 z7 + 1691 z6 + 1857 z5 + 1903 z4 + 1102 z3

+ 1932 z2 + 1878 z + 1584.

De berekening van voorgaande vierkantswortel gebeurt op basis van

√z = 1866 z26 + 801 z25 + 61 z24 + 1655 z23 + 1732 z22 + 1853 z21

+280 z20 + 1088 z19 + 548 z18 + 1653 z17 + 1383 z16 + 1236 z15

+ 1097 z14 + 184 z13 + 1873 z12 + 1304 z11 + 489 z10 + 1720 z9

+ 581 z8 + 531 z7 + 687 z6 + 592 z5 + 1641 z4 + 1268 z3

+ 159 z2 + 1365 z + 948.

Twee veeltermen a(z) en b(z) die voldoen aan de vergelijking a(z) = b(z)R(z),zijn

a(z) = z13 + 109 z12 + 949 z11 + 224 z10 + 23 z9 + 1178 z8

+1488 z7 + 1825 z6 + 641 z5 + 645 z4 + 257 z3 + 128 z2

+ 1626 z + 1908.

71

A. Patterson-testvectoren

en

b(z) = 2040 z13 + 1704 z12 + 1586 z11 + 1756 z10 + 1845 z9 + 1285 z8

+1757 z7 + 1977 z6 + 1311 z5 + 957 z4 + 1379 z3 + 1155 z2

+ 972 z + 1901.

De foutlocatie veelterm σ(z) = a2(z) + zb2(z) wordt dan

σ(z) = 1351 z27 + 1 z26 + 1261 z25 + 1115 z24 + 1409 z23 + 1817 z22

+ 503 z21 + 1058 z20 + 1332 z19 + 277 z18 + 692 z17 + 873 z16

+ 502 z15 + 903 z14 + 1356 z13 + 1060 z12 + 1008 z11 + 681 z10

+ 1881 z9 + 697 z8 + 1706 z7 + 161 z6 + 552 z5 + 40 z4

+ 594 z3 + 459 z2 + 1150 z + 1343.

De nulpunten van σ(z) geven de positie van de t = 27 bitfouten in het ontvangencodewoord r′ aan:

σ(z) = 1351 (z + 18) (z + 226) (z + 310) (z + 411) (z + 421) (z + 491)(z + 532) (z + 655) (z + 695) (z + 752) (z + 772) (z + 889)(z + 1150) (z + 1405) (z + 1438) (z + 1441) (z + 1606) (z + 1607)(z + 1631) (z + 1691) (z + 1710) (z + 1796) (z + 1863) (z + 1889)(z + 1902) (z + 1955) (z + 2031).

72

Bĳlage B

Eindig-veldbouwblokken

GEZEL-code wordt achtereenvolgens gespecificeerd voor de volgende eindig-veldoperaties:vermenigvuldiging, vermenigvuldiging met x, kwadratering, het nemen van devierkantswortel en inversie.

B.1 Vermenigvuldiging

1 dp gf_mul ( in a , b : ns (11) ;2 out c : ns (11) ) {3 sig a0b0 , a0b1 , a0b2 , a0b3 , a0b4 , a0b5 , a0b6 , a0b7 ,4 a0b8 , a0b9 , a0b10 , a1b0 , a1b1 , a1b2 , a1b3 , a1b4 , a1b5 ,5 a1b6 , a1b7 , a1b8 , a1b9 , a1b10 , a2b0 , a2b1 , a2b2 , a2b3 ,6 a2b4 , a2b5 , a2b6 , a2b7 , a2b8 , a2b9 , a2b10 , a3b0 , a3b1 ,7 a3b2 , a3b3 , a3b4 , a3b5 , a3b6 , a3b7 , a3b8 , a3b9 , a3b10 ,8 a4b0 , a4b1 , a4b2 , a4b3 , a4b4 , a4b5 , a4b6 , a4b7 , a4b8 ,9 a4b9 , a4b10 , a5b0 , a5b1 , a5b2 , a5b3 , a5b4 , a5b5 , a5b6 ,

10 a5b7 , a5b8 , a5b9 , a5b10 , a6b0 , a6b1 , a6b2 , a6b3 , a6b4 ,11 a6b5 , a6b6 , a6b7 , a6b8 , a6b9 , a6b10 , a7b0 , a7b1 , a7b2 ,12 a7b3 , a7b4 , a7b5 , a7b6 , a7b7 , a7b8 , a7b9 , a7b10 , a8b0 ,13 a8b1 , a8b2 , a8b3 , a8b4 , a8b5 , a8b6 , a8b7 , a8b8 , a8b9 ,14 a8b10 , a9b0 , a9b1 , a9b2 , a9b3 , a9b4 , a9b5 , a9b6 , a9b7 ,15 a9b8 , a9b9 , a9b10 , a10b0 , a10b1 , a10b2 , a10b3 , a10b4 ,16 a10b5 , a10b6 , a10b7 , a10b8 , a10b9 , a10b10 , s0 , s1 , s2 ,17 s3 , s4 , s5 , s6 , s7 , s8 , s9 , s10 , s11 , s12 , s13 , s14 ,18 s15 , s16 , s17 , s18 , s19 , s20 , c0 , c1 , c2 , c3 , c4 , c5 ,19 c6 , c7 , c8 , c9 , c10 , cx : ns (1 ) ;20 sfg run {21 a0b0 = a [ 0 ] & b [ 0 ] ; a0b1 = a [ 0 ] & b [ 1 ] ;22 a0b2 = a [ 0 ] & b [ 2 ] ; a0b3 = a [ 0 ] & b [ 3 ] ;23 a0b4 = a [ 0 ] & b [ 4 ] ; a0b5 = a [ 0 ] & b [ 5 ] ;24 a0b6 = a [ 0 ] & b [ 6 ] ; a0b7 = a [ 0 ] & b [ 7 ] ;25 a0b8 = a [ 0 ] & b [ 8 ] ; a0b9 = a [ 0 ] & b [ 9 ] ;

73

B. Eindig-veldbouwblokken

26 a0b10 = a [ 0 ] & b [ 1 0 ] ;27 a1b0 = a [ 1 ] & b [ 0 ] ; a1b1 = a [ 1 ] & b [ 1 ] ;28 a1b2 = a [ 1 ] & b [ 2 ] ; a1b3 = a [ 1 ] & b [ 3 ] ;29 a1b4 = a [ 1 ] & b [ 4 ] ; a1b5 = a [ 1 ] & b [ 5 ] ;30 a1b6 = a [ 1 ] & b [ 6 ] ; a1b7 = a [ 1 ] & b [ 7 ] ;31 a1b8 = a [ 1 ] & b [ 8 ] ; a1b9 = a [ 1 ] & b [ 9 ] ;32 a1b10 = a [ 1 ] & b [ 1 0 ] ;33 a2b0 = a [ 2 ] & b [ 0 ] ; a2b1 = a [ 2 ] & b [ 1 ] ;34 a2b2 = a [ 2 ] & b [ 2 ] ; a2b3 = a [ 2 ] & b [ 3 ] ;35 a2b4 = a [ 2 ] & b [ 4 ] ; a2b5 = a [ 2 ] & b [ 5 ] ;36 a2b6 = a [ 2 ] & b [ 6 ] ; a2b7 = a [ 2 ] & b [ 7 ] ;37 a2b8 = a [ 2 ] & b [ 8 ] ; a2b9 = a [ 2 ] & b [ 9 ] ;38 a2b10 = a [ 2 ] & b [ 1 0 ] ;39 a3b0 = a [ 3 ] & b [ 0 ] ; a3b1 = a [ 3 ] & b [ 1 ] ;40 a3b2 = a [ 3 ] & b [ 2 ] ; a3b3 = a [ 3 ] & b [ 3 ] ;41 a3b4 = a [ 3 ] & b [ 4 ] ; a3b5 = a [ 3 ] & b [ 5 ] ;42 a3b6 = a [ 3 ] & b [ 6 ] ; a3b7 = a [ 3 ] & b [ 7 ] ;43 a3b8 = a [ 3 ] & b [ 8 ] ; a3b9 = a [ 3 ] & b [ 9 ] ;44 a3b10 = a [ 3 ] & b [ 1 0 ] ;45 a4b0 = a [ 4 ] & b [ 0 ] ; a4b1 = a [ 4 ] & b [ 1 ] ;46 a4b2 = a [ 4 ] & b [ 2 ] ; a4b3 = a [ 4 ] & b [ 3 ] ;47 a4b4 = a [ 4 ] & b [ 4 ] ; a4b5 = a [ 4 ] & b [ 5 ] ;48 a4b6 = a [ 4 ] & b [ 6 ] ; a4b7 = a [ 4 ] & b [ 7 ] ;49 a4b8 = a [ 4 ] & b [ 8 ] ; a4b9 = a [ 4 ] & b [ 9 ] ;50 a4b10 = a [ 4 ] & b [ 1 0 ] ;51 a5b0 = a [ 5 ] & b [ 0 ] ; a5b1 = a [ 5 ] & b [ 1 ] ;52 a5b2 = a [ 5 ] & b [ 2 ] ; a5b3 = a [ 5 ] & b [ 3 ] ;53 a5b4 = a [ 5 ] & b [ 4 ] ; a5b5 = a [ 5 ] & b [ 5 ] ;54 a5b6 = a [ 5 ] & b [ 6 ] ; a5b7 = a [ 5 ] & b [ 7 ] ;55 a5b8 = a [ 5 ] & b [ 8 ] ; a5b9 = a [ 5 ] & b [ 9 ] ;56 a5b10 = a [ 5 ] & b [ 1 0 ] ;57 a6b0 = a [ 6 ] & b [ 0 ] ; a6b1 = a [ 6 ] & b [ 1 ] ;58 a6b2 = a [ 6 ] & b [ 2 ] ; a6b3 = a [ 6 ] & b [ 3 ] ;59 a6b4 = a [ 6 ] & b [ 4 ] ; a6b5 = a [ 6 ] & b [ 5 ] ;60 a6b6 = a [ 6 ] & b [ 6 ] ; a6b7 = a [ 6 ] & b [ 7 ] ;61 a6b8 = a [ 6 ] & b [ 8 ] ; a6b9 = a [ 6 ] & b [ 9 ] ;62 a6b10 = a [ 6 ] & b [ 1 0 ] ;63 a7b0 = a [ 7 ] & b [ 0 ] ; a7b1 = a [ 7 ] & b [ 1 ] ;64 a7b2 = a [ 7 ] & b [ 2 ] ; a7b3 = a [ 7 ] & b [ 3 ] ;65 a7b4 = a [ 7 ] & b [ 4 ] ; a7b5 = a [ 7 ] & b [ 5 ] ;66 a7b6 = a [ 7 ] & b [ 6 ] ; a7b7 = a [ 7 ] & b [ 7 ] ;67 a7b8 = a [ 7 ] & b [ 8 ] ; a7b9 = a [ 7 ] & b [ 9 ] ;68 a7b10 = a [ 7 ] & b [ 1 0 ] ;69 a8b0 = a [ 8 ] & b [ 0 ] ; a8b1 = a [ 8 ] & b [ 1 ] ;70 a8b2 = a [ 8 ] & b [ 2 ] ; a8b3 = a [ 8 ] & b [ 3 ] ;

74

B.1. Vermenigvuldiging

71 a8b4 = a [ 8 ] & b [ 4 ] ; a8b5 = a [ 8 ] & b [ 5 ] ;72 a8b6 = a [ 8 ] & b [ 6 ] ; a8b7 = a [ 8 ] & b [ 7 ] ;73 a8b8 = a [ 8 ] & b [ 8 ] ; a8b9 = a [ 8 ] & b [ 9 ] ;74 a8b10 = a [ 8 ] & b [ 1 0 ] ;75 a9b0 = a [ 9 ] & b [ 0 ] ; a9b1 = a [ 9 ] & b [ 1 ] ;76 a9b2 = a [ 9 ] & b [ 2 ] ; a9b3 = a [ 9 ] & b [ 3 ] ;77 a9b4 = a [ 9 ] & b [ 4 ] ; a9b5 = a [ 9 ] & b [ 5 ] ;78 a9b6 = a [ 9 ] & b [ 6 ] ; a9b7 = a [ 9 ] & b [ 7 ] ;79 a9b8 = a [ 9 ] & b [ 8 ] ; a9b9 = a [ 9 ] & b [ 9 ] ;80 a9b10 = a [ 9 ] & b [ 1 0 ] ;81 a10b0 = a [ 1 0 ] & b [ 0 ] ; a10b1 = a [ 1 0 ] & b [ 1 ] ;82 a10b2 = a [ 1 0 ] & b [ 2 ] ; a10b3 = a [ 1 0 ] & b [ 3 ] ;83 a10b4 = a [ 1 0 ] & b [ 4 ] ; a10b5 = a [ 1 0 ] & b [ 5 ] ;84 a10b6 = a [ 1 0 ] & b [ 6 ] ; a10b7 = a [ 1 0 ] & b [ 7 ] ;85 a10b8 = a [ 1 0 ] & b [ 8 ] ; a10b9 = a [ 1 0 ] & b [ 9 ] ;86 a10b10 = a [ 1 0 ] & b [ 1 0 ] ;87 s0 = a0b0 ;88 s1 = a0b1 ^ a1b0 ;89 s2 = a0b2 ^ a1b1 ^ a2b0 ;90 s3 = a0b3 ^ a1b2 ^ a2b1 ^ a3b0 ;91 s4 = a0b4 ^ a1b3 ^ a2b2 ^ a3b1 ^ a4b0 ;92 s5 = a0b5 ^ a1b4 ^ a2b3 ^ a3b2 ^ a4b1 ^ a5b0 ;93 s6 = a0b6 ^ a1b5 ^ a2b4 ^ a3b3 ^ a4b2 ^ a5b1 ^ a6b0 ;94 s7 = a0b7 ^ a1b6 ^ a2b5 ^ a3b4 ^ a4b3 ^ a5b2 ^ a6b1

^ a7b0 ;95 s8 = a0b8 ^ a1b7 ^ a2b6 ^ a3b5 ^ a4b4 ^ a5b3 ^ a6b2

^ a7b1 ^ a8b0 ;96 s9 = a0b9 ^ a1b8 ^ a2b7 ^ a3b6 ^ a4b5 ^ a5b4 ^ a6b3

^ a7b2 ^ a8b1 ^ a9b0 ;97 s10 = a0b10 ^ a1b9 ^ a2b8 ^ a3b7 ^ a4b6 ^ a5b5 ^

a6b4 ^ a7b3 ^ a8b2 ^ a9b1 ^ a10b0 ;98 s11 = a1b10 ^ a2b9 ^ a3b8 ^ a4b7 ^ a5b6 ^ a6b5 ^

a7b4 ^ a8b3 ^ a9b2 ^ a10b1 ;99 s12 = a2b10 ^ a3b9 ^ a4b8 ^ a5b7 ^ a6b6 ^ a7b5 ^

a8b4 ^ a9b3 ^ a10b2 ;100 s13 = a3b10 ^ a4b9 ^ a5b8 ^ a6b7 ^ a7b6 ^ a8b5 ^

a9b4 ^ a10b3 ;101 s14 = a4b10 ^ a5b9 ^ a6b8 ^ a7b7 ^ a8b6 ^ a9b5 ^

a10b4 ;102 s15 = a5b10 ^ a6b9 ^ a7b8 ^ a8b7 ^ a9b6 ^ a10b5 ;103 s16 = a6b10 ^ a7b9 ^ a8b8 ^ a9b7 ^ a10b6 ;104 s17 = a7b10 ^ a8b9 ^ a9b8 ^ a10b7 ;105 s18 = a8b10 ^ a9b9 ^ a10b8 ;106 s19 = a9b10 ^ a10b9 ;107 s20 = a10b10 ;

75


108 cx = s11 ^ s20 ;109 c0 = s0 ^ cx ;110 c1 = s1 ^ s12 ;111 c2 = s2 ^ s13 ^ cx ;112 c3 = s3 ^ s14 ^ s12 ;113 c4 = s4 ^ s15 ^ s13 ;114 c5 = s5 ^ s16 ^ s14 ;115 c6 = s6 ^ s17 ^ s15 ;116 c7 = s7 ^ s18 ^ s16 ;117 c8 = s8 ^ s19 ^ s17 ;118 c9 = s9 ^ s20 ^ s18 ;119 c10 = s10 ^ s19 ;120 c = c10 # c9 # c8 # c7 # c6 # c5 # c4 # c3 # c2 # c1

# c0 ;121 }122 }123 hardwired h_gf_mul ( gf_mul ) {run ; }

B.2 Vermenigvuldiging met x

1 dp gf_mul_x( in a : ns (11) ;2 out c : ns (11) ) {3 sig c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 : ns (1 ) ;4 sfg run {5 c0 = a [ 1 0 ] ; c1 = a [ 0 ] ; c2 = a [ 1 ] ^ a [ 1 0 ] ;6 c3 = a [ 2 ] ; c4 = a [ 3 ] ; c5 = a [ 4 ] ; c6 = a [ 5 ] ;7 c7 = a [ 6 ] ; c8 = a [ 7 ] ; c9 = a [ 8 ] ; c10 = a [ 9 ] ;8 c = c10 # c9 # c8 # c7 # c6 # c5 # c4 # c3 # c2 # c1

# c0 ;9 }10 }11 hardwired h_gf_mul_x(gf_mul_x) {run ; }

B.3 Kwadratering

1 dp gf_square ( in a : ns (11) ;2 out c : ns (11) ) {3 sig c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 : ns (1 ) ;4 sfg run {5 c0 = a [ 0 ] ^ a [ 1 0 ] ; c1 = a [ 6 ] ; c2 = a [ 1 ] ^ a [ 1 0 ] ;6 c3 = a [ 6 ] ^ a [ 7 ] ; c4 = a [ 2 ] ; c5 = a [ 7 ] ^ a [ 8 ] ;7 c6 = a [ 3 ] ; c7 = a [ 8 ] ^ a [ 9 ] ; c8 = a [ 4 ] ;8 c9 = a [ 9 ] ^ a [ 1 0 ] ; c10 = a [ 5 ] ;9 c = c10 # c9 # c8 # c7 # c6 # c5 # c4 # c3 # c2 # c1

# c0 ;

76

B.4. Vierkantswortel

10 }11 }12 hardwired h_gf_square ( gf_square ) {run ; }

B.4 Vierkantswortel

1 dp gf_sqrt ( in a : ns (11) ;2 out c : ns (11) ) {3 sig c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 : ns (1 ) ;4 sfg run {5 c2 = a [ 4 ] ; c3 = a [ 6 ] ; c4 = a [ 8 ] ; c5 = a [ 1 0 ] ;6 c6 = a [ 1 ] ; c7 = a [ 1 ] ^ a [ 3 ] ; c8 = c7 ^ a [ 5 ] ;7 c9 = c8 ^ a [ 7 ] ; c10 = c9 ^ a [ 9 ] ; c0 = c10 ^ a [ 0 ] ;8 c1 = c10 ^ a [ 2 ] ;9 c = c10 # c9 # c8 # c7 # c6 # c5 # c4 # c3 # c2 # c1

# c0 ;10 }11 }12 hardwired h_gf_sqrt ( g f_sqrt ) {run ; }

B.5 Inversie

1 dp gf_inv ( in gf_in : ns (11) ;2 in s t a r t : ns (1 ) ;3 out gf_out : ns (11) ;4 out gf_out_valid : ns (1 ) ;5 out ready : ns (1 ) ) {6 sig square_out , mul_in , mul_out , square_in : ns (11) ;7 reg reg_counter : ns (4 ) ;8 reg reg_star t : ns (1 ) ;9 reg reg_resu l t , reg_square : ns (11) ;

10 use gf_mul2 ( square_out , mul_in , mul_out ) ;11 use gf_square ( square_in , square_out ) ;12 sfg i d l e {13 square_in = gf_in ;14 reg_counter = 0 ;15 mul_in = 1 ;16 }17 sfg s tep {18 square_in = reg_square ;19 mul_in = reg_re su l t ;20 reg_counter = reg_counter + 1 ;21 }22 sfg ready_0 { ready = 0 ;}23 sfg ready_1 { ready = 1 ;}

77


24 sfg c_valid_0 {gf_out_valid = 0 ;}25 sfg c_valid_1 {gf_out_valid = 1 ;}26 sfg run {27 reg_re su l t = mul_out ;28 gf_out = reg_re su l t ;29 reg_star t = s t a r t ;30 reg_square = square_out ;31 }32 }33 fsm gf_inv_ctl ( gf_inv ) {34 i n i t i a l s0 ;35 state s1 , s2 ;36 @s0 ( run , i d l e , ready_1 , c_valid_0 ) −> s1 ;37 @s1 i f ( r eg_star t ) then ( run , step , ready_0 , c_valid_0 ) −>

s2 ;38 e l s e ( run , i d l e , ready_1 , c_valid_0 ) −> s1 ;39 @s2 i f ( reg_counter == 9) then ( run , i d l e , ready_1 ,

c_valid_1 ) −> s1 ;40 e l s e ( run , step , ready_0 , c_valid_0 ) −> s2 ;41 }

78

Bĳlage C

Veeltermbouwblokken

Hier worden de veeltermoperaties op RTL-niveau behandeld. Eerst wordt de strate-gie voor het lezen en schrijven van coëfficiënten toegelicht. Daarna worden deafzonderlijke bouwblokken en hun bijhorende GEZEL-implementatie besproken.

C.1 Lezen en schrijven van coëfficiëntenAlle veeltermalgoritmes zijn in essentie lees- en schrijfoperaties op de coëfficiëntvan één of meer veeltermen. Twee mogelijke benaderingen geven toegang tot deindividuele coëfficiënten.

C.1.1 Multiplexer-gebaseerd

In de architectuur van figuur C.1 is de toegankelijkheid van de coëfficiënten optimaal:ze kunnen onafhankelijk van elkaar gelezen of overschreven worden. Het veelvuldigegebruik van multiplexers heeft twee grote nadelen. Allereerst nemen ze een signifi-cante oppervlakte in. Verder zorgt de grote lees-multiplexer voor een aanzienlijketijdvertraging.

MUX

MUX MUX MUX MUX MUX MUX

11Eindig Veld

Operaties

11

Figuur C.1: Multiplexer-gebaseerde coëfficiënt bewerkingen.

79

C. Veeltermbouwblokken

C.1.2 FIFO-gebaseerd

De architectuur van figuur C.2 is zeer efficiënt in termen van oppervlakte. Veeltermcoëfficiënten zijn nu enkel toegankelijk volgens oplopende of aflopende graad. Voor debesproken veelterm algoritmes is dit echter niet problematisch. De vereiste ontwerp-tijd per bouwblok verhoogt wel lichtelijk door de soms gecompliceerde synchronisatievan meerdere veelterm-FIFO’s.

11Eindig Veld

Operaties

MUX11

Figuur C.2: FIFO-gebaseerde coëfficiënt bewerkingen.

Het voornaamste nadeel is echter de verhoogde laad- en ontlaad activiteit α. DeFIFO-architectuur verhoogt het totale dynamisch vermogen [46]

Pdyn = α f CL V2DD.

Hierbij is f de klokfrequentie, CL de lastcapaciteit en VDD de voedingsspanning. Ditis meteen ook het voornaamste nadeel van deze architectuur. Door een afname vanhet totaal aantal transistoren verlaagt echter het totale statische vermogen

Pstat = Ileak VDD.

C.1.3 Besluit

De keuze is eigenlijk vooral afhankelijk van het applicatie. Geen van beide architec-turen geniet een duidelijke voorkeur. De bouwblokken worden systematisch op eenFIFO-gebaseerde manier ontworpen.

C.2 FIFOFIFO’s van lengte 14, 27 en 28 worden voorzien.

1 dp gf_14_f i fo ( in gf_in : ns (11) ;2 in en : ns (1 ) ;3 out gf_out : ns (11) ) {4 reg reg_coe f f0 , reg_coe f f1 , reg_coe f f2 , reg_coe f f3 ,5 reg_coe f f4 , reg_coe f f5 , reg_coe f f6 , reg_coe f f7 ,6 reg_coe f f8 , reg_coe f f9 , reg_coef f10 , reg_coef f11 ,7 reg_coef f12 , r eg_coe f f13 : ns (11) ;8 sfg run {9 reg_coe f f 0 = en ? gf_in : r eg_coe f f 0 ;

80

C.3. Veelterm-accumulator (POLY_ACCUMUL)

10 reg_coe f f 1 = en ? reg_coe f f 0 : r eg_coe f f 1 ;11 reg_coe f f 2 = en ? reg_coe f f 1 : r eg_coe f f 2 ;12 reg_coe f f 3 = en ? reg_coe f f 2 : r eg_coe f f 3 ;13 reg_coe f f 4 = en ? reg_coe f f 3 : r eg_coe f f 4 ;14 reg_coe f f 5 = en ? reg_coe f f 4 : r eg_coe f f 5 ;15 reg_coe f f 6 = en ? reg_coe f f 5 : r eg_coe f f 6 ;16 reg_coe f f 7 = en ? reg_coe f f 6 : r eg_coe f f 7 ;17 reg_coe f f 8 = en ? reg_coe f f 7 : r eg_coe f f 8 ;18 reg_coe f f 9 = en ? reg_coe f f 8 : r eg_coe f f 9 ;19 reg_coe f f10 = en ? reg_coe f f 9 : r eg_coe f f10 ;20 reg_coe f f11 = en ? reg_coe f f10 : r eg_coe f f11 ;21 reg_coe f f12 = en ? reg_coe f f11 : r eg_coe f f12 ;22 reg_coe f f13 = en ? reg_coe f f12 : r eg_coe f f13 ;23 gf_out = reg_coe f f13 ;24 }25 }26 hardwired h_gf_14_fifo ( g f_14_f i fo ) {run ; }

C.3 Veelterm-accumulator (POLY_ACCUMUL)

1 dp poly_accumulator ( in s t a r t : ns (1 ) ;2 in stop : ns (1 ) ;3 in r e s e t : ns (1 ) ;4 in empty : ns (1 ) ;5 in gf_in : ns (11) ;6 in gf_in_val id : ns (1 ) ;7 out gf_out : ns (11) ;8 out gf_out_valid : ns (1 ) ) {9 sig f i f o_ in , f i f o_out : ns (11) ;

10 reg r_cnt : ns (5 ) ;11 reg r_empty , r_start , r_rese t : ns (1 ) ;12 sig f i f o_en : ns (1 ) ;13 use gf_28_f i fo6 ( f i f o_ in , f i fo_en , f i f o_out ) ;14 sfg run {15 f i f o_en = ( s t a r t | r_star t ) &16 ( gf_in_val id | empty | r_empty ) & (~ stop ) ;17 r_cnt = f i f o_en ?18 ( ( r_cnt == 27) ? 0 : ( r_cnt + 1) ) : r_cnt ;19 f i f o_ i n = ( r_rese t | r e s e t ) ? gf_in :20 ( f i f o_out ^ gf_in ) ;21 gf_out_valid = empty | r_empty ;22 r_reset = ( r_cnt == 27) ? 0 : ( r_rese t | r e s e t ) ;23 r_empty = ( r_cnt == 27) ? 0 : ( r_empty | empty ) ;24 r_star t = s t a r t ? 1 : ( stop ? 0 : r_star t ) ;

81


25 gf_out = gf_out_valid ? f i f o_out : 0 ;26 }27 }28 hardwired h_poly_accumulator ( poly_accumulator ) {run ; }

C.4 Programmeerbare veelterm (POLY_BENCH)POLY_BENCH omvat een programmeerbare veelterm waarvan men de coëfficiëntenindividueel kan adresseren vanuit de PicoBlaze. De enige functie is tot dusver hetopslaan van de veelterm z. Deze wordt enerzijds opgeteld bij de syndroominverseT (z) en vormt anderzijds een vermenigvuldiger bij berekenen van σ(z).

1 dp poly_bench ( in s t a r t : ns (1 ) ;2 in r e s e t : ns (1 ) ;3 out ready : ns (1 ) ;4 in gf_in : ns (11) ;5 in gf_in_val id : ns (1 ) ;6 in gf_in_index : ns (5 ) ;7 out gf_out : ns (11) ;8 out gf_out_valid : ns (1 ) ) {9 sig gf_in_index2 : ns (5 ) ;10 sig f i f o_ in , f i fo_out , gf_in2 : ns (11) ;11 reg r_cnt , r_gf_in_index : ns (5 ) ;12 reg r_start , r_reset , r_gf_in_valid : ns (1 ) ;13 sig f i f o_en : ns (1 ) ;14 reg r_gf_in : ns (11) ;15 sig cnt_next : ns (5 ) ;16 use gf_28_f i fo9 ( f i f o_ in , f i fo_en , f i f o_out ) ;17 sfg run {18 f i f o_en = ( s t a r t | r_star t ) |19 ( gf_in_val id | r_gf_in_valid ) ;20 r_cnt = f i f o_en ? cnt_next : r_cnt ;21 f i f o_ i n = ((27 − r_cnt ) == gf_in_index2 ) ? gf_in2 :

( ( r_rese t | r e s e t ) ? 0 : f i f o_out ) ;22 gf_out_valid = s t a r t | r_star t ;23 r_rese t = ( r_cnt == 27) ? 0 : ( r_rese t | r e s e t ) ;24 r_star t = ( r_cnt == 27) ? 0 : ( r_star t | s t a r t ) ;25 r_gf_in_valid = ( r_cnt == 27) ? 0 :26 ( r_gf_in_valid | g f_in_val id ) ;27 ready = ( r_cnt == 0) & ~( s t a r t | r_star t |

g f_in_val id | r_gf_in_valid ) ;28 gf_out = gf_out_valid ? f i f o_out : 0 ;29 r_gf_in = gf_in_val id ? gf_in : r_gf_in ;30 r_gf_in_index = gf_in_val id ? gf_in_index :

r_gf_in_index ;31 gf_in2 = ( r_cnt == 0) ? gf_in : r_gf_in ;

82

C.5. Wachtrij van eindig-veldelementen (POLY_QUEUE)

32 gf_in_index2 = ( r_cnt == 0) ? gf_in_index :r_gf_in_index ;

33 cnt_next = ( r_cnt == 27) ? 0 : ( r_cnt + 1) ;34 }35 }36 hardwired h_poly_bench ( poly_bench ) {run ; }

C.5 Wachtrij van eindig-veldelementen(POLY_QUEUE)

1 dp gf_queue ( in s t a r t : ns (1 ) ;2 in stop : ns (1 ) ;3 in r e s e t : ns (1 ) ;4 in out_next : ns (1 ) ;5 out empty : ns (1 ) ;6 in gf_in : ns (11) ;7 in gf_in_val id : ns (1 ) ;8 out gf_out : ns (11) ;9 out gf_out_valid : ns (1 ) ) {

10 sig f i f o_ in , f i f o_out : ns (11) ;11 sig f i f o_en : ns (1 ) ;12 use gf_28_f i fo10 ( gf_in , f i fo_en , gf_out ) ;13 reg r_cnt , r_cnt2 : ns (5 ) ;14 reg r_start , r_empty , r_out_next : ns (1 ) ;15 sig cnta , cntb : ns (5 ) ;16 sfg run {17 sig cnt : ns (11) ;18 cnt = r e s e t ? 0 : ( f i f o_en ? cnta : r_cnt ) ;19 r_cnt = cnt ;20 r_cnt2 = ( f i f o_en & gf_in_val id ) ? cnt : r_cnt2 ;21 f i f o_en = ( s t a r t | r_star t ) & ( gf_in_val id | ( (

out_next | r_out_next ) & (~r_empty ) ) ) & (~ stop ) ;22 r_star t = s t a r t ? 1 : ( stop ? 0 : r_star t ) ;23 r_empty = r e s e t ? 0 : ( ( cntb == r_cnt2 ) ? 1 :

r_empty ) ;24 gf_out_valid = cnta < r_cnt2 ;25 empty = r_empty ;26 r_out_next = gf_out_valid ? 0 : ( ( out_next & (~

gf_out_valid ) ) ? 1 : r_out_next ) ;27 cnta = ( r_cnt == 28) ? 0 : ( r_cnt + 1) ;28 cntb = ( r_cnt == 27) ? 0 : ( r_cnt + 2) ;29 }30 }

83


31 hardwired h_gf_queue ( gf_queue ) {run ; }

C.6 Veelterm-conversie (POLY_TURN)De POLY_TURN bouwblok converteert een veelterm met oplopende graad naaraflopende graad en vice versa. Een LIFO van t+ 1 elementen volstaat.

1 dp turnaround ( in load : ns (1 ) ;2 in s t a r t : ns (1 ) ;3 out ready : ns (1 ) ;4 in gf_in : ns (11) ;5 in gf_in_val id : ns (1 ) ;6 out gf_out : ns (11) ;7 out gf_out_valid : ns (1 ) ) {8 sig en_in , en_out : ns (1 ) ;9 use g f_28_l i fo ( gf_in , en_in , en_out , gf_out ) ;10 reg r_cnt : ns (5 ) ;11 reg r_start , r_load : ns (1 ) ;12 sfg run {13 r_star t = ( r_cnt == 27) ? 0 : ( r_star t | s t a r t ) ;14 r_load = ( r_cnt == 27) ? 0 : ( r_load | load ) ;15 ready = ( r_cnt == 0) ;16 en_in = ( r_load | load ) & gf_in_val id ;17 en_out = ( r_star t | s t a r t ) ;18 gf_out_valid = en_out ;19 r_cnt = ( en_in | en_out ) ? ( ( r_cnt == 27) ? 0 :20 ( r_cnt + 1) ) : r_cnt ;21 }22 }23 hardwired h_turnaround ( turnaround ) {run ; }

C.7 Veelterm-vermenigvuldiging (POLY_MUL)De POLY_MUL bouwblok vermenigvuldigt twee veeltermen, met als voorwaardedat de resultante hoogstens graad t heeft. Er vindt dus geen modulo-operatieplaats. Ingaande veeltermen p1 en p2 zijn respectievelijk de vermenigvuldiger en hetvermenigvuldigtal.

1 dp poly_mul ( in load_p1 : ns (1 ) ;2 in load_p2 : ns (1 ) ;3 in load_square : ns (1 ) ;4 in s t a r t : ns (1 ) ;5 out ready : ns (1 ) ;6 in gf_in : ns (11) ;7 in gf_in_val id : ns (1 ) ;8 out gf_out : ns (11) ;

84

C.7. Veelterm-vermenigvuldiging (POLY_MUL)

9 out gf_out_valid : ns (1 ) ) {10 sig f i f o1_ in , f i f o2_ in , f i fo1_out , f i fo2_out ,11 mul_out : ns (11) ;12 sig f i fo1_en , f i f o2_en : ns (1 ) ;13 use gf_28_f i fo7 ( f i f o1_ in , f i fo1_en , f i f o1_out ) ;14 use gf_28_f i fo8 ( f i f o2_ in , f i fo2_en , f i f o2_out ) ;15 use gf_mul10 ( f i fo1_out , f i fo2_out , mul_out ) ;16 reg r_cnt1 , r_cnt2 : ns (5 ) ;17 sig cnt1_next , cnt2_next : ns (5 ) ;18 reg r_gf_in : ns (11) ;19 reg r_gf_in_valid , r_load_p1 , r_load_p2 , r_star t : ns (1 ) ;20 reg r_done , r_ f in i shed : ns (1 ) ;21 sig cnt_comp : ns (5 ) ;22 sfg acq_0 { f i f o 1_ in = f i f o1_out ; f i f o 2_ in = f i f o2_out ; }23 sfg acq_1 {24 sig done : ns (1 ) ;25 f i f o 1_ in = r_gf_in ; f i f o 2_ in = r_gf_in ;26 f i f o1_en = ( r_load_p1 ) & r_gf_in_valid ;27 f i f o2_en = ( r_load_p2 ) & r_gf_in_valid ;28 r_cnt1 = f i f o1_en ? cnt1_next : r_cnt1 ;29 r_cnt2 = f i f o2_en ? cnt2_next : r_cnt2 ;30 done = r_load_p1 ? ( r_cnt1 == 0) :31 ( r_load_p2 ? ( r_cnt2 == 0) : 0) ;32 r_done = done ;33 }34 sfg i d l e {35 r_load_p1 = load_p1 | load_square ;36 r_load_p2 = load_p2 | load_square ;37 r_star t = s t a r t ;38 r_cnt1 = 27 ; r_cnt2 = 27 ;39 }40 sfg f i f o s _ i d l e {41 f i f o1_en = 0 ;42 f i f o2_en = 0 ;43 }44 sfg a l i gn_mu l t i p l i e r {45 sig done1 : ns (1 ) ;46 done1 = ( f i f o1_out != 0) | ( r_cnt1 == 0) ;47 f i f o1_en = ~done1 ;48 f i f o2_en = 0 ;49 r_cnt1 = f i f o1_en ? cnt1_next : r_cnt1 ;50 r_done = done1 ;51 }52 sfg a l i gn_mul t ip l i cand {53 sig done2 : ns (1 ) ;

85


54 done2 = ( r_cnt1 + r_cnt2 == 27) ;55 f i f o1_en = 0 ;56 f i f o2_en = ~done2 ;57 r_cnt2 = f i f o2_en ? cnt2_next : r_cnt2 ;58 r_done = done2 ;59 }60 sfg out_valid_1 {61 sig done3 : ns (1 ) ;62 done3 = ( r_cnt2 == cnt_comp) ;63 gf_out_valid = (~done3 ) | (~ r_done ) ;64 f i f o1_en = 0 ;65 f i f o2_en = ~done3 ;66 r_cnt2 = f i f o2_en ? cnt2_next : r_cnt2 ;67 r_done = done3 ;68 }69 sfg s h i f t_mu l t i p l i e r {70 f i f o1_en = 1 ;71 f i f o2_en = 0 ;72 r_cnt1 = f i f o1_en ? cnt1_next : r_cnt1 ;73 r_ f in i shed = ( r_cnt1 == 0) ;74 }75 sfg out_valid_0 {gf_out_valid = 0 ;}76 sfg run {77 cnt1_next = ( r_cnt1 == 0) ? 27 : ( r_cnt1 − 1) ;78 cnt2_next = ( r_cnt2 == 0) ? 27 : ( r_cnt2 − 1) ;79 cnt_comp = ( r_cnt1 == 0) ? 0 : (28 − r_cnt1 ) ;80 r_gf_in = gf_in ;81 r_gf_in_valid = gf_in_val id ;82 ready = ~( r_load_p1 | load_p1 | r_load_p2 | load_p2

| load_square | r_star t | s t a r t ) ;83 gf_out = gf_out_valid ? mul_out : 0 ;84 }85 }86 fsm poly_mul_ctl ( poly_mul ) {87 i n i t i a l s0 ;88 state s1 , s2 , s3 , s4 , s5 , s6 ;89 @s0 ( run , i d l e , acq_0 , f i f o s_ i d l e , out_valid_0 ) −> s1 ;90 @s1 i f ( r_load_p1 | r_load_p2 )91 then ( run , acq_1 , out_valid_0 ) −> s2 ;92 e l s e i f ( r_star t )93 then ( run , a l i gn_mul t i p l i e r , acq_0 , out_valid_0 )

−> s3 ;94 e l s e ( run , i d l e , f i f o s_ i d l e , acq_0 , out_valid_0 )

−> s1 ;95 @s2 i f ( r_done )

86

C.8. Vierkantswortel (POLY_SQRT_EO en POLY_SQRT)

96 then ( run , i d l e , acq_0 , f i f o s_ i d l e , out_valid_0 ) −>s1 ;

97 e l s e ( run , acq_1 , out_valid_0 ) −> s2 ;98 @s3 i f ( r_done )99 then ( run , a l ign_mult ip l i cand , acq_0 , out_valid_0 )

−> s4 ;100 e l s e ( run , a l i gn_mul t i p l i e r , acq_0 , out_valid_0 ) −>

s3 ;101 @s4 i f ( r_done )102 then ( run , acq_0 , out_valid_1 ) −> s5 ;103 e l s e ( run , a l ign_mult ip l i cand , acq_0 , out_valid_0 )

−> s4 ;104 @s5 i f ( r_done )105 then ( run , acq_0 , s h i f t_mu l t i p l i e r , out_valid_0 ) −>

s6 ;106 e l s e ( run , acq_0 , out_valid_1 ) −> s5 ;107 @s6 i f ( r_ f in i shed )108 then ( run , acq_0 , f i f o s_ i d l e , out_valid_0 , i d l e ) −>

s1 ;109 e l s e ( run , a l ign_mult ip l i cand , acq_0 , out_valid_0 )

−> s4 ;110 }

C.8 Vierkantswortel (POLY_SQRT_EO enPOLY_SQRT)

De vierkantswortel-functionaliteit wordt verdeeld over twee bouwblokken. POLY_SQRT_EOneemt eerst de vierkantswortel van de coëfficiënten van de ingaande veelterm ensplits deze volgens even en oneven graad. Op basis van de getabelleerde veelterm√z, berekent de bouwblok POLY_SQRT hiermee de vierkantswortel. Om flip-flops

te besparen, kan men beide bouwblokken ook integreren in één enkele bouwblok.Wanneer men de McEleice-sleutelgeneratie eveneens in hardware uitvoert heeft menwel baat bij deze opsplitsing.

1 dp poly_sqrt_even_odd ( in load : ns (1 ) ;2 in start_even : ns (1 ) ;3 in start_odd : ns (1 ) ;4 out ready : ns (1 ) ;5 in gf_in : ns (11) ;6 in gf_in_val id : ns (1 ) ;7 out gf_out : ns (11) ;8 out gf_out_valid : ns (1 ) ) {9 sig f i fo_even_in , f i fo_even_out , f i fo_odd_in ,

fifo_odd_out , gf_in_sqrt : ns (11) ;

87


10 sig f i fo_even_en , f i fo_even_en1 , f i fo_even_en2 ,fifo_odd_en , fifo_odd_en1 , fifo_odd_en2 : ns (1 ) ;

11 use gf_sqrt ( gf_in , gf_in_sqrt ) ;12 use gf_14_f i fo ( f i fo_even_in , f i fo_even_en ,13 f i fo_even_out ) ;14 use gf_14_f i fo2 ( f i fo_odd_in , fifo_odd_en , f i fo_odd_out ) ;15 reg r_cnt : ns (5 ) ;16 reg r_load , r_start_even , r_start_odd : ns (1 ) ;17 sfg run {18 r_load = ( r_cnt == 27) ? 0 : ( r_load | load ) ;19 r_start_even = ( r_cnt == 27) ? 0 :20 ( r_start_even | start_even ) ;21 r_start_odd = ( r_cnt == 27) ? 0 :22 ( r_start_odd | start_odd ) ;23 f i fo_even_en1 = ( r_load | load ) & ( r_cnt [ 0 ] == 1) &

gf_in_val id ;24 f i fo_even_en2 = ( r_start_even | start_even ) &25 ( r_cnt > 13) ;26 f i fo_even_en = fi fo_even_en1 | f i fo_even_en2 ;27 fifo_odd_en1 = ( r_load | load ) & ( r_cnt [ 0 ] == 0) &

gf_in_val id ;28 fifo_odd_en2 = ( r_start_odd | start_odd ) &29 ( r_cnt > 13) ;30 fifo_odd_en = fifo_odd_en1 | fifo_odd_en2 ;31 r_cnt = ( f i fo_even_en1 | fifo_odd_en1 | r_start_odd

| start_odd | r_start_even | start_even ) ? ( (r_cnt == 27) ? 0 : ( r_cnt + 1) ) : r_cnt ;

32 gf_out = ( r_cnt > 13) ? ( ( r_start_even | start_even )? f i fo_even_out : f i fo_odd_out ) : 0 ;

33 gf_out_valid = r_start_even | start_even |r_start_odd | start_odd ;

34 f i fo_even_in = ( r_load | load ) ? gf_in_sqrt :f i fo_even_out ;

35 f i fo_odd_in = ( r_load | load ) ? gf_in_sqrt :f i fo_odd_out ;

36 ready = ~( r_start_even | start_even | r_start_odd |start_odd | r_load | load ) ;

37 }38 }39 hardwired h_poly_sqrt_even_odd ( poly_sqrt_even_odd ) {run ; }

1 dp poly_sqrt ( in load_sqrt_even : ns (1 ) ;2 in load_sqrt_odd : ns (1 ) ;3 in load_sqrt_z : ns (1 ) ;4 in s t a r t : ns (1 ) ;

88

C.8. Vierkantswortel (POLY_SQRT_EO en POLY_SQRT)

5 in empty_sqrt : ns (1 ) ;6 out ready : ns (1 ) ;7 in coe f f_g : ns (11) ;8 out coeff_g_next : ns (1 ) ;9 in gf_in : ns (11) ;

10 in gf_in_val id : ns (1 ) ;11 out gf_out : ns (11) ;12 out gf_out_valid : ns (1 ) ) {13 reg r_load_sqrt_even , r_load_sqrt_odd , r_load_sqrt_z ,14 r_start , r_gf_in_valid , r_done ,15 r_empty_sqrt : ns (1 ) ;16 reg r_gf_in , r_msb : ns (11) ;17 sig f i f o_res_in , f i fo_res_out , f i f o_sqr t_in ,18 fi fo_odd_in , f i fo_sqrt_out , fifo_odd_out , prod1 ,19 prod2 , sum1 , sum2 : ns (11) ;20 sig f i fo_res_en , f i fo_sqrt_en , fifo_odd_en : ns (1 ) ;21 use gf_27_f i fo2 ( f i f o_res_in , f i fo_res_en , f i f o_res_out ) ;22 use gf_27_f i fo ( f i f o_sqr t_in , f i fo_sqrt_en ,23 f i f o_sqr t_out ) ;24 use gf_14_f i fo3 ( f i fo_odd_in , fifo_odd_en , f i fo_odd_out ) ;25 use gf_mul11 ( f i fo_sqrt_out , fifo_odd_out , prod1 ) ;26 use gf_mul12 ( coef f_g , r_msb , prod2 ) ;27 reg r_cnt : ns (5 ) ;28 reg r_cnt2 : ns (4 ) ;29 sig cnt_next : ns (5 ) ;30 sfg i d l e {31 r_load_sqrt_even = load_sqrt_even ;32 r_load_sqrt_odd = load_sqrt_odd ;33 r_load_sqrt_z = load_sqrt_z ;34 r_star t = s t a r t ;35 r_empty_sqrt = empty_sqrt ;36 f i f o_sqrt_en = 0 ; fifo_odd_en = 0 ; f i f o_res_en = 0 ;37 f i f o_sq r t_ in = r_gf_in ; f i fo_odd_in = r_gf_in ;38 f i f o_re s_ in = r_gf_in ;39 coeff_g_next = 0 ;40 gf_out_valid = 0 ; gf_out = 0 ;41 }42 sfg acq_1 {43 sig cnt : ns (1 ) ;44 f i f o_sq r t_ in = r_gf_in ;45 f i f o_sqrt_en = r_load_sqrt_z & r_gf_in_valid ;46 f i fo_odd_in = r_gf_in ;47 fifo_odd_en = r_load_sqrt_odd & r_gf_in_valid &48 ( r_cnt < 14) ;49 f i f o_re s_ in = r_gf_in ;

89


50 f i f o_res_en = r_load_sqrt_even & r_gf_in_valid ;51 cnt = ( f i f o_sqrt_en | ( r_load_sqrt_odd &

r_gf_in_valid ) | f i f o_res_en ) ;52 r_cnt = cnt ? cnt_next : r_cnt ;53 r_done = ( r_cnt == 27) & cnt ;54 coeff_g_next = 0 ;55 gf_out_valid = 0 ; gf_out = 0 ;56 }57 sfg acq_0 {58 f i f o_sq r t_ in = ( r_cnt == 0) ? 0 : sum2 ;59 f i f o_sqrt_en = 1 ;60 f i fo_odd_in = r_gf_in ;61 fifo_odd_en = ( r_cnt == 27) ;62 f i f o_re s_ in = sum1 ;63 f i f o_res_en = ( r_cnt != 27) ;64 r_cnt = cnt_next ;65 r_msb = ( r_cnt == 0) ? f i f o_sqr t_out : r_msb ;66 coeff_g_next = 1 ;67 r_done = ( r_cnt == 27) & ( r_cnt2 == 12) ;68 r_cnt2 = ( r_cnt == 27) ? ( r_cnt2 + 1) : r_cnt2 ;69 gf_out_valid = 0 ; gf_out = 0 ;70 }71 sfg out_val id {72 f i f o_sqrt_en = 0 ; fifo_odd_en = 0 ;73 f i f o_res_en = ( r_cnt != 0) ;74 f i f o_sq r t_ in = r_gf_in ; f i fo_odd_in = r_gf_in ;75 f i f o_re s_ in = r_gf_in ;76 coeff_g_next = 0 ;77 r_cnt = cnt_next ;78 gf_out_valid = 1 ; gf_out = ( r_cnt == 0) ? 0 :

f i f o_res_out ;79 }80 sfg run {81 cnt_next = ( r_cnt == 27) ? 0 : ( r_cnt + 1) ;82 r_gf_in = gf_in ; r_gf_in_valid = gf_in_val id ;83 sum1 = ( prod1 ^ f i f o_res_out ) ;84 sum2 = prod2 ^ f i f o_sqr t_out ;85 ready = ~( r_load_sqrt_even | load_sqrt_even86 | r_load_sqrt_odd | load_sqrt_odd |87 r_load_sqrt_z | load_sqrt_z | r_star t |88 s t a r t | empty_sqrt | r_empty_sqrt ) ;89 }90 }91 fsm poly_sqrt_ct l ( poly_sqrt ) {92 i n i t i a l s0 ;

90

C.9. Variant op het uitgebreide algoritme van Euclides (POLY_EUCLID)

93 state s1 , s2 , s3 , s4 ;94 @s0 ( run , i d l e ) −> s1 ;95 @s1 i f ( r_load_sqrt_z | r_load_sqrt_even |

r_load_sqrt_odd )96 then ( run , acq_1 ) −> s2 ;97 e l s e i f ( r_star t )98 then ( run , acq_0 ) −> s3 ;99 e l s e i f ( r_empty_sqrt )100 then ( run , out_val id ) −> s4 ;101 e l s e ( run , i d l e ) −> s1 ;102 @s2 i f ( r_done )103 then ( run , i d l e ) −> s1 ;104 e l s e ( run , acq_1 ) −> s2 ;105 @s3 i f ( r_done )106 then ( run , i d l e ) −> s1 ;107 e l s e ( run , acq_0 ) −> s3 ;108 @s4 i f ( r_done )109 then ( run , i d l e ) −> s1 ;110 e l s e ( run , out_val id ) −> s4 ;111 }

C.9 Variant op het uitgebreide algoritme van Euclides(POLY_EUCLID)

1 dp extended_eucl id ( in load_p1 : ns (1 ) ;2 in load_p2 : ns (1 ) ;3 in empty_u : ns (1 ) ;4 in empty_gcd : ns (1 ) ;5 in s t a r t : ns (1 ) ;6 in fu l l_n_hal f : ns (1 ) ;7 out ready : ns (1 ) ;8 in poly_in : ns (11) ;9 in poly_in_val id : ns (1 ) ;

10 out poly_out : ns (11) ;11 out poly_out_valid : ns (1 ) ) {12 reg r_start , reg_stop , reg_inv_ready , reg_ful l_n_half ,13 reg_swap , reg_f i fo s_length_set , reg_start_inv ,14 reg_inv_valid , reg_f i fo1_length_set ,15 reg_f i fo2_length_set , r_poly_in_valid , r_load_p1 ,16 r_load_p2 , r_empty_u , r_empty_gcd : ns (1 ) ;17 sig f i f o1_ in , f i f o2_ in , f i f o3_ in , f i f o4_ in , f i fo1_out ,18 f i fo2_out , f i fo3_out , f i fo4_out , Ai , Bi , qBi , Ai2 ,19 Ci , Di , qDi , Ci2 , lcA , lcB , inv_out , q : ns (11) ;

91


20 sig f i fo1_en , f i fo2_en , f i fo3_en , f i fo4_en , sw , stop ,21 inv_start , inv_val id , poly_in_acq , f i f o s_ l ength_se t ,22 inv_ready : ns (1 ) ;23 reg reg_f i fo1_lc , r eg_f i fo2_lc , reg_q , reg_q_new ,24 r_poly_in : ns (11) ;25 reg reg_counter_f i fo1 , reg_counter_f i fo2 ,26 reg_counter_f i fo3 , reg_f i fo1_length ,27 reg_f i f o2_length : ns (5 ) ;28 reg r eg_di f f e r ence_counter : tc (6 ) ;29 sig d i f f e r e n c e : tc (6 ) ;30 sig length_A , length_B , stopcond : ns (5 ) ;31 use gf_28_f i fo1 ( f i f o1_ in , f i fo1_en , f i f o1_out ) ;32 use gf_28_f i fo2 ( f i f o2_ in , f i fo2_en , f i f o2_out ) ;33 use gf_28_f i fo3 ( f i f o3_ in , f i fo3_en , f i f o3_out ) ;34 use gf_28_f i fo4 ( f i f o4_ in , f i fo4_en , f i f o4_out ) ;35 use gf_mul3 (Bi , reg_q , qBi ) ;36 use gf_inv ( lcB , inv_start , inv_out , inv_val id ,

inv_ready ) ;37 use gf_mul4 ( lcA , inv_out , q ) ;38 use gf_mul5 (Di , reg_q , qDi ) ;39 sfg acq_0 {40 f i f o 1_ in = reg_swap ? Bi : Ai2 ;41 f i f o 2_ in = reg_swap ? Ai2 : Bi ;42 f i f o 3_ in = reg_swap ? Di : Ci2 ;43 f i f o 4_ in = reg_swap ? Ci2 : Di ;44 poly_in_acq = 0 ;45 }46 sfg acq_1 {47 f i f o 1_ in = r_poly_in ; f i f o 2_ in = r_poly_in ;48 f i f o 3_ in = 0 ; f i f o 4_ in = ( reg_counter_f i fo2 == 1) ;49 poly_in_acq = 1 ;50 }51 sfg new_round {52 reg_f i fo1_length_set = 0 ; reg_f i fo2_length_set = 0 ;53 reg_f i f o s_length_set = 0 ;54 reg_counter_f i fo1 = 28 ; reg_counter_f i fo2 = 28 ;55 reg_counter_f i fo3 = 28 ;56 reg_swap = ( d i f f e r e n c e <= 0) ;57 reg_di f f e r ence_counter = d i f f e r e n c e ;58 reg_stop = stop ;59 }60 sfg s e tq {reg_q = reg_q_new ;}61 sfg di f f_counter_increment { reg_di f f e r ence_counter =

reg_di f f e r ence_counter + 1 ;}

92


62 sfg dif f_counter_decrement { reg_di f f e r ence_counter =reg_di f f e r ence_counter − 1 ;}

63 sfg f i f o 1_ s h i f t {64 sig t r i g g e r 1 : ns (1 ) ;65 f i f o1_en = poly_in_acq ? r_poly_in_valid : 1 ;66 reg_counter_f i fo1 = f i f o1_en ?67 ( reg_counter_f i fo1 − 1) : reg_counter_f i fo1 ;68 t r i g g e r 1 = ((~ reg_f i fo1_length_set ) & ( ( f i f o 1_ in !=

0) | ( reg_counter_f i fo1 == 1) ) ) ;69 reg_f i fo1_length_set = reg_f i fo1_length_set |

t r i g g e r 1 ;70 r eg_f i f o1_ l c = t r i g g e r 1 ? f i f o 1_ in : r eg_f i f o1_ l c ;71 reg_f i f o1_length = t r i g g e r 1 ? ( ( reg_counter_f i fo1 ==

1) ? ( f i f o 1_ in != 0) : reg_counter_f i fo1 ) :r eg_f i f o1_length ;

72 }73 sfg f i f o 3_ s h i f t {74 f i f o3_en = poly_in_acq ? r_poly_in_valid : 1 ;75 reg_counter_f i fo3 = f i f o3_en ?76 ( reg_counter_f i fo3 − 1) : reg_counter_f i fo3 ;77 }78 sfg f i f o 3_ i d l e { f i f o3_en = 0 ;}79 sfg f i f o 1_ i d l e { f i f o1_en = 0 ;}80 sfg f i f o 4_ s h i f t { f i f o4_en = poly_in_acq ?

r_poly_in_valid : 1 ; }81 sfg f i f o 4_ i d l e { f i f o4_en = 0 ;}82 sfg f i f o 2_ s h i f t {83 sig t r i g g e r 2 : ns (1 ) ;84 f i f o2_en = poly_in_acq ? r_poly_in_valid : 1 ;85 reg_counter_f i fo2 = f i f o2_en ?86 ( reg_counter_f i fo2 − 1) : reg_counter_f i fo2 ;87 t r i g g e r 2 = ((~ reg_f i fo2_length_set ) & ( ( f i f o 2_ in !=

0) | ( reg_counter_f i fo2 == 1) ) ) ;88 reg_f i fo2_length_set = reg_f i fo2_length_set |

t r i g g e r 2 ;89 r eg_f i f o2_ l c = t r i g g e r 2 ? f i f o 2_ in : r eg_f i f o2_ l c ;90 reg_f i f o2_length = t r i g g e r 2 ? ( ( reg_counter_f i fo2 ==

1) ? ( f i f o 2_ in != 0) : reg_counter_f i fo2 ) :r eg_f i f o2_length ;

91 }92 sfg f i f o 2_ i d l e { f i f o2_en = 0 ;}93 sfg round { reg_f i f o s_length_set = f i f o s_ l eng th_se t ; }94 sfg run {95 length_B = ( reg_f i f o1_length > reg_f i f o2_length ) ?

reg_f i f o2_length : r eg_f i f o1_length ;

93


96 length_A = ( reg_f i f o1_length > reg_f i f o2_length ) ?reg_f i f o1_length : r eg_f i f o2_length ;

97 stop = ( length_B == 0) | ( length_A <= stopcond ) ;98 d i f f e r e n c e = ( tc (6 ) ) reg_f i f o1_length − ( tc (6 ) )

r eg_f i f o2_length ;99 reg_q_new = inv_val id ? q : reg_q_new ;

100 reg_inv_ready = inv_ready & (~ inv_start ) ;101 f i f o s_ l eng th_se t = reg_f i fo1_length_set &

reg_f i fo2_length_set ;102 inv_start = (~ reg_f i f o s_length_set ) &

f i f o s_ l eng th_se t ;103 lcB = stop ? ( ( d i f f e r e n c e > 0) ? r eg_f i f o1_ l c :

r eg_f i f o2_ l c ) : ( ( d i f f e r e n c e > 0) ? r eg_f i f o2_ l c: r eg_f i f o1_ l c ) ;

104 lcA = stop ? 1 : ( ( d i f f e r e n c e > 0) ? r eg_f i f o1_ l c :r eg_f i f o2_ l c ) ;

105 Ai = reg_swap ? f i f o2_out : f i f o1_out ;106 Bi = reg_stop ? ( reg_swap ? f i f o2_out : f i f o1_out ) :

( reg_swap ? f i f o1_out : f i f o2_out ) ;107 Ci = reg_swap ? f i f o4_out : f i f o3_out ;108 Di = reg_stop ? ( reg_swap ? f i f o4_out : f i f o3_out ) :

( reg_swap ? f i f o3_out : f i f o4_out ) ;109 Ai2 = Ai ^ qBi ; Ci2 = Ci ^ qDi ;110 r_poly_in = poly_in ;111 r_poly_in_valid = poly_in_val id ;112 ready = ~( r_load_p1 | load_p1 | r_load_p2 | load_p2 |

r_empty_u | empty_u | r_empty_gcd | empty_gcd |r_star t | s t a r t ) ;

113 stopcond = reg_ful l_n_hal f ? 1 : 14 ;114 }115 sfg i d l e {116 r_load_p1 = load_p1 ; r_load_p2 = load_p2 ;117 r_empty_u = empty_u ; r_empty_gcd = empty_gcd ;118 reg_ful l_n_hal f = fu l l_n_hal f ;119 r_star t = s t a r t ;120 }121 sfg out_valid_0 {poly_out = Ai ; poly_out_valid = 0 ;}122 sfg out_valid_gcd {poly_out = qBi ; poly_out_valid = 1 ;}123 sfg out_valid_u {poly_out = qDi ; poly_out_valid = 1 ;}124 sfg ready_0 { ready = 0 ;}125 }126127 fsm extended_eucl id_ct l ( extended_eucl id ) {128 i n i t i a l s0 ;129 state s1 , s2 , s2b , s3 , s4 , s5 , s5b ;

94


130 @s0 ( run , i d l e , new_round , f i f o 1_ i d l e , f i f o 3_ i d l e ,f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 , out_valid_0 ) −> s1 ;

131 @s1 i f ( r_load_p1 )132 then ( run , round , f i f o 1_ sh i f t , f i f o 3_ sh i f t ,

f i f o 2_ i d l e , f i f o 4_ i d l e , acq_1 , out_valid_0 ) −> s2;

133 e l s e i f ( r_load_p2 )134 then ( run , round , f i f o 1_ i d l e , f i f o 3_ i d l e ,

f i f o 2_ sh i f t , f i f o 4_ sh i f t , acq_1 , out_valid_0 )−> s2b ;

135 e l s e i f ( r_star t )136 then ( run , new_round , f i f o 1_ i d l e , f i f o 3_ i d l e

, f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 ,out_valid_0 ) −> s3 ;

137 e l s e i f ( r_empty_u)138 then ( run , f i f o 1_ i d l e , f i f o 3_ i d l e ,

f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 ,out_valid_0 ) −> s5 ;

139 e l s e i f ( r_empty_gcd )140 then ( run , f i f o 1_ i d l e , f i f o 3_ i d l e ,

f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 ,out_valid_0 ) −> s5b ;

141 e l s e ( run , i d l e , f i f o 1_ i d l e ,f i f o 3_ i d l e , f i f o 2_ i d l e ,f i f o 4_ i d l e , acq_0 , out_valid_0 )−> s1 ;

142 @s2 i f ( reg_counter_f i fo1 == 0)143 then ( run , i d l e , round , f i f o 1_ i d l e , f i f o 2_ i d l e ,


144 e l s e ( run , round , f i f o 1_ sh i f t , f i f o 3_ sh i f t ,f i f o 2_ i d l e , f i f o 4_ i d l e , acq_1 , out_valid_0 ) −> s2;

145 @s2b i f ( reg_counter_f i fo2 == 0)146 then ( run , i d l e , round , f i f o 1_ i d l e , f i f o 2_ i d l e ,


147 e l s e ( run , round , f i f o 1_ i d l e , f i f o 3_ i d l e ,f i f o 2_ sh i f t , f i f o 4_ sh i f t , acq_1 , out_valid_0 ) −>s2b ;

148 @s3 i f ( reg_stop )149 then i f ( reg_inv_ready )150 then ( run , setq , i d l e , f i f o 1_ i d l e , f i f o 3_ i d l e ,

f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 , out_valid_0 )−> s1 ;

95


151 e l s e ( run , f i f o 1_ i d l e , f i f o 3_ i d l e , f i f o 2_ i d l e ,f i f o 4_ i d l e , acq_0 , out_valid_0 ) −> s3 ;

152 e l s e i f ( r eg_di f f e r ence_counter == 0)153 then i f ( reg_inv_ready )154 then ( run , setq , round , f i f o 1_ i d l e ,

f i f o 3_ i d l e , f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0, out_valid_0 ) −> s4 ;

155 e l s e ( run , round , f i f o 1_ i d l e , f i f o 3_ i d l e ,f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 ,out_valid_0 ) −> s3 ;

156 e l s e i f ( r eg_di f f e r ence_counter > 0)157 then ( run , round , f i f o 1_ i d l e , f i f o 3_ i d l e ,

f i f o 2_ sh i f t , f i f o 4_ sh i f t ,di f f_counter_decrement , acq_0 ,out_valid_0 ) −> s3 ;

158 e l s e ( run , round , f i f o 1_ sh i f t , f i f o 3_ sh i f t ,f i f o 2_ i d l e , f i f o 4_ i d l e ,d i f f_counter_increment , acq_0 ,out_valid_0 ) −> s3 ;

159 @s4 i f ( ( reg_counter_f i fo1 != 0) & ( reg_counter_f i fo2 !=0) )

160 then ( run , round , f i f o 1_ sh i f t , f i f o 3_ sh i f t ,f i f o 2_ sh i f t , f i f o 4_ sh i f t , acq_0 , out_valid_0 ) −>s4 ;

161 e l s e i f ( ( reg_counter_f i fo1 == 0) & (reg_counter_f i fo2 != 0) )

162 then ( run , round , f i f o 1_ i d l e , f i f o 3_ i d l e ,f i f o 2_ sh i f t , f i f o 4_ sh i f t , acq_0 , out_valid_0 )−> s4 ;

163 e l s e i f ( ( reg_counter_f i fo1 != 0) & (reg_counter_f i fo2 == 0) )

164 then ( run , round , f i f o 1_ sh i f t , f i f o 3_ sh i f t ,f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 ,out_valid_0 ) −> s4 ;

165 e l s e ( run , new_round , f i f o 1_ i d l e , f i f o 3_ i d l e, f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 ,out_valid_0 ) −> s3 ;

166 @s5 i f ( reg_counter_f i fo3 == 0)167 then ( run , i d l e , f i f o 1_ i d l e , f i f o 3_ i d l e ,

f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 , out_valid_0 )−> s1 ;

168 e l s e ( run , f i f o 1_ i d l e , f i f o 3_ sh i f t , f i f o 2_ i d l e ,f i f o 4_ sh i f t , acq_0 , out_valid_u ) −> s5 ;

169 @s5b i f ( reg_counter_f i fo1 == 0)

96

C.10. Lineaire-veelterminversie (POLY_INVZA)

170 then ( run , i d l e , f i f o 1_ i d l e , f i f o 3_ i d l e ,f i f o 2_ i d l e , f i f o 4_ i d l e , acq_0 , out_valid_0 )−> s1 ;

171 e l s e ( run , f i f o 1_ sh i f t , f i f o 3_ i d l e , f i f o 2_ sh i f t ,f i f o 4_ i d l e , acq_0 , out_valid_gcd ) −> s5b ;

172 }

C.10 Lineaire-veelterminversie (POLY_INVZA)Het inverteren van gemiddeld n/2 lineaire veeltermen z + ai wordt versneld metbehulp van pipelining: drie stages van t+ 1 klokcycli benutten de hardware optimaal.De eerste stage evalueert generatorveelterm g(z) voor het element ai volgens hetHorner schema. De tweede stage inverteert de resultante g(ai). De derde stageproduceert de uitgaande coëfficiënten volgens aflopende graad. Deze bouwblok issignificant voor de totale decryptiesnelheid. Het gemiddelde aantal klokcycli vooreen syndroomberekening bedraagt (n/2 + 2)(t+ 1) = 28728.

1 dp inv_z_plus_a ( in s t a r t : ns (1 ) ;2 out ready : ns (1 ) ;3 in coe f f_g : ns (11) ;4 out coe f f_g_sh i f t : ns (1 ) ;5 in a : ns (11) ;6 out a_acq : ns (1 ) ;7 out coe f f_ inv : ns (11) ;8 out coe f f_ inv_va l id : ns (1 ) ) {9 sig start_load_g , start_stage1 , s ta r t_stage2 : ns (1 ) ;

10 reg r_start_load_g , r_start_stage1 , r_start_stage2 ,r_start_stage3 : ns (1 ) ;

11 reg r_a_stage1 , r_a_stage2 , r_a_stage3 : ns (11) ;12 reg r_cnt : ns (5 ) ;13 reg r_g_eval , r_ga_inv , r_coeff27_inv ,14 r_coef f_inv : ns (11) ;15 sig prod1 , sum1 , prod2 , prod3 , sum2 , ga_inv : ns (11) ;16 sig ga_inv_valid , inv_ready : ns (1 ) ;17 use gf_mul7 ( r_a_stage1 , r_g_eval , prod1 ) ;18 use gf_mul8 ( coef f_g , r_coeff27_inv , prod2 ) ;19 use gf_mul9 ( r_a_stage3 , r_coeff_inv , prod3 ) ;20 use gf_inv2 (sum1 , start_stage2 , ga_inv , ga_inv_valid ,

inv_ready ) ;21 sfg run {22 s ta r t_stage1 = ( r_cnt == 0) ? s t a r t : 0 ;23 r_start_stage1 = ( r_cnt == 0) ? s t a r t :

r_start_stage1 ;24 s ta r t_stage2 = ( r_cnt == 27) ? r_start_stage1 : 0 ;25 r_start_stage2 = ( r_cnt == 27) ? r_start_stage1 :

r_start_stage2 ;

97


26 r_start_stage3 = ( r_cnt == 27) ? r_start_stage2 :r_start_stage3 ;

27 coe f f_g_sh i f t = star t_stage1 | r_start_stage1 |s ta r t_stage2 | r_start_stage2 | r_start_stage3 ;

28 r_cnt = coe f f_g_sh i f t ? ( ( r_cnt == 27) ? 0 : ( r_cnt+ 1) ) : r_cnt ;

29 r_a_stage1 = star t_stage1 ? a : r_a_stage1 ;30 a_acq = star t_stage1 ;31 sum1 = coef f_g ^ prod1 ;32 r_g_eval = ( r_cnt == 27) ? 0 : sum1 ;33 r_a_stage2 = ( r_cnt == 27) ? r_a_stage1 :34 r_a_stage2 ;35 r_a_stage3 = ( r_cnt == 27) ? r_a_stage2 :36 r_a_stage3 ;37 r_ga_inv = ga_inv_valid ? ga_inv : r_ga_inv ;38 sum2 = prod2 ^ prod3 ;39 r_coef f27_inv = ( r_cnt == 27) ? r_ga_inv :

r_coef f27_inv ;40 r_coef f_inv = ( r_cnt == 27) ? 0 : ( r_start_stage3 ?

sum2 : r_coef f_inv ) ;41 coe f f_ inv = r_coef f_inv ;42 coe f f_ inv_va l id = r_start_stage3 ;43 ready = ~( r_start_load_g | r_start_stage1 |

r_start_stage2 | r_start_stage3 ) ;44 }45 }46 hardwired h_inv_z_plus_a ( inv_z_plus_a ) {run ; }

C.11 Algoritme van Chien (POLY_CHIEN)De POLY_CHIEN bouwblok, die de nulpunten van foutlocatieveelterm σ(z) zoekt,is significant voor de totale decryptiesnelheid. Het totaal aantal klokcycli met deonderstaande implementatie bedraagt ongeveer (n− 1)(t+ 1) = 57316.

1 dp chien_search ( in load : ns (1 ) ;2 in s t a r t : ns (1 ) ;3 out ready : ns (1 ) ;4 in s igma_coef f : ns (11) ;5 in s igma_coef f_val id : ns (1 ) ;6 out root : ns (11) ;7 out root_val id : ns (1 ) ) {8 sig f i f o_ in , f i fo_out , root_next , alpha_i_next ,9 prod , sum : ns (11) ;10 sig f i f o_en : ns (1 ) ;11 reg r_alpha_i , r_root , r_accumulator ,

98

C.11. Algoritme van Chien (POLY_CHIEN)

12 r_sigma_coeff : ns (11) ;13 reg r_start , r_load , r_ready , r_done ,14 r_sigma_coeff_val id : ns (1 ) ;15 use gf_mul13 ( r_alpha_i , f i f o_out , prod ) ;16 use gf_mul_x( r_root , root_next ) ;17 use gf_28_f i fo11 ( f i f o_ in , f i fo_en , f i f o_out ) ;18 use gf_mul_x2 ( r_alpha_i , alpha_i_next ) ;19 sfg i d l e {20 r_alpha_i = 1 ; r_root = 0 ;21 r_load = load ; r_star t = s t a r t ;22 f i f o_en = 0 ; root_val id = 0 ;23 f i f o_ i n = r_sigma_coeff ;24 r_accumulator = 0 ;25 }26 sfg acq {27 f i f o_ i n = r_sigma_coeff ;28 f i f o_en = r_sigma_coef f_val id ;29 root_val id = 0 ;30 r_alpha_i = r_sigma_coeff_val id ? ( ( r_alpha_i == 0

x220 ) ? 1 : alpha_i_next ) : r_alpha_i ;31 r_done = ( r_alpha_i == 0x220 ) ;32 }33 sfg search {34 f i f o_ i n = prod ; f i f o_en = 1 ;35 root_val id = ( ( r_root == 0) | ( r_alpha_i == 0x220 ) )

? (sum == 0) : 0 ;36 r_done = ( r_root == 0x402 ) & ( r_alpha_i == 0x220 ) ;37 r_root = ( r_root == 0) ? 1 : ( ( r_alpha_i == 0x220 ) ?

root_next : r_root ) ;38 r_alpha_i = ( r_alpha_i == 0x220 ) ? 1 : alpha_i_next ;39 r_accumulator = ( r_alpha_i == 0x220 ) ? 0 : sum ;40 }41 sfg run {42 r_sigma_coeff = sigma_coef f ;43 r_sigma_coeff_val id = sigma_coef f_val id ;44 root = r_root ;45 ready = ~( load | r_load | s t a r t | r_star t ) ;46 sum = r_accumulator ^ f i f o_out ;47 }48 }49 fsm ch ien_search_ct l ( chien_search ) {50 i n i t i a l s0 ;51 state s1 , s2 , s3 ;52 @s0 ( run , i d l e ) −> s1 ;53 @s1 i f ( r_load )

99


54 then ( run , acq ) −> s2 ;55 e l s e i f ( r_star t )56 then ( run , search ) −> s3 ;57 e l s e ( run , i d l e ) −> s1 ;58 @s2 i f ( r_done )59 then ( run , i d l e ) −> s1 ;60 e l s e ( run , acq ) −> s2 ;61 @s3 i f ( r_done )62 then ( run , i d l e ) −> s1 ;63 e l s e ( run , search ) −> s3 ;64 }

C.12 Hard gecodeerde veeltermen (REG_G enREG_SQRTZ)

1 dp reg_f i l e_g ( in s t a r t : ns (1 ) ;2 in nex t c o e f f : ns (1 ) ;3 in a l i g n : ns (1 ) ;4 out ready : ns (1 ) ;5 out c o e f f : ns (11) ;6 out c o e f f_va l i d : ns (1 ) ) {7 lookup poly : ns (11) = {1 , 1566 , 1543 , 1803 , 2030 , 1137 ,

1295 , 1601 , 146 , 1826 , 1292 , 1690 , 1367 , 1993 , 128 ,1676 , 1708 , 1052 , 154 , 340 , 146 , 1125 , 871 , 296 , 359 ,1566 , 102 , 1433} ;

8 reg r_cnt : ns (5 ) ;9 reg r_star t : ns (1 ) ;10 sfg run {11 c o e f f = poly ( r_cnt ) ;12 co e f f_va l i d = ( s t a r t | r_star t ) ;13 r_star t = ( r_cnt == 27) ? 0 : ( r_star t | s t a r t ) ;14 r_cnt = a l i g n ? 0 : ( c o e f f_va l i d | n e x t c o e f f ? ( (

r_cnt == 27) ? 0 : ( r_cnt + 1) ) : r_cnt ) ;15 ready = ( r_cnt == 0) ;16 }17 }18 hardwired h_reg_file_g ( reg_f i l e_g ) {run ; }

100

Bĳlage D

Matrixbouwblokken

GEZEL-code wordt gespecificeerd voor twee bouwblokken die betrekking hebben totde neutralisatie van scramblingmatrix S. Eerst wordt een implementatie van hetTRIVIUM-stroomcijfer gegeven die 32 bits per klokcyclus genereert; deze is gebaseerdop GEZEL-code uit [49]. Vervolgens wordt de code gegeven voor de bouwblok dieop basis van de TRIVIUM-bits de boodschap m accumuleert.

D.1 TRIVIUM_PRNG

1 dp t r iv ium ( in s i : ns (288) ;2 out so : ns (288) ;3 out z : ns (1 ) ) {4 sig t1 , t2 , t3 : ns (1 ) ;5 sig t11 , t22 , t33 : ns (1 ) ;6 sig saa : ns (93) ;7 sig sbb : ns (84) ;8 sig s cc : ns (111) ;9 sfg run {

10 t1 = s i [ 65 ] ^ s i [ 9 2 ] ;11 t2 = s i [ 1 6 1 ] ^ s i [ 1 7 6 ] ;12 t3 = s i [ 2 4 2 ] ^ s i [ 2 8 7 ] ;13 z = t1 ^ t2 ^ t3 ;14 t11 = t1 ^ ( s i [ 90 ] & s i [ 9 1 ] ) ^ s i [ 1 7 0 ] ;15 t22 = t2 ^ ( s i [ 1 7 4 ] & s i [ 1 7 5 ] ) ^ s i [ 2 6 3 ] ;16 t33 = t3 ^ ( s i [ 2 8 5 ] & s i [ 2 8 6 ] ) ^ s i [ 6 8 ] ;17 saa = s i [ 0 : 91 ] # t33 ;18 sbb = s i [ 9 3 : 1 75 ] # t11 ;19 scc = s i [ 1 7 7 : 2 8 6 ] # t22 ;20 so = scc # sbb # saa ;21 }22 }

101

D. Matrixbouwblokken

1 dp trivium_prng ( in load : ns (1 ) ;2 in i v : ns (80) ;3 in key : ns (80) ;4 out rand : ns (32) ;5 out ready : ns (1 ) ;6 in nextt : ns (1 ) ) {7 sig s i , so0 , so1 , so2 , so3 , so4 , so5 , so6 , so7 , so8 ,8 so9 , so10 , so11 , so12 , so13 , so14 , so15 , so16 ,9 so17 , so18 , so19 , so20 , so21 , so22 , so23 , so24 ,10 so25 , so26 , so27 , so28 , so29 , so30 , so31 : ns (288) ;11 sig z0 , z1 , z2 , z3 , z4 , z5 , z6 , z7 , z8 , z9 , z10 , z11 ,12 z12 , z13 , z14 , z15 , z16 , z17 , z18 , z19 , z20 , z21 ,13 z22 , z23 , z24 , z25 , z26 , z27 , z28 , z29 , z30 ,14 z31 : ns (1 ) ;15 reg r_s : ns (288) ; reg r_cnt : ns (6 ) ;16 sig saa : ns ( 93) ; sig sbb : ns ( 84) ;17 sig scc , c t e : ns (111) ;18 sig cte1 : ns (108) ; sig cte2 : ns (3 ) ;19 use t r iv ium ( so0 , so1 , z0 ) ;20 use tr iv ium2 ( so1 , so2 , z1 ) ;21 . . .22 use tr iv ium31 ( so30 , so31 , z30 ) ;23 use tr iv ium32 ( so31 , s i , z31 ) ;24 sfg run {25 rand = z0 # z1 # z2 # z3 # z4 # z5 # z6 # z7 # z826 # z9 # z10 # z11 # z12 # z13 # z14 # z15 # z1627 # z17 # z18 # z19 # z20 # z21 # z22 # z23 # z2428 # z25 # z26 # z27 # z28 # z29 # z30 # z31 ;29 saa = load ? key : s i [ 0 : 9 2 ] ;30 sbb = load ? iv : s i [ 9 3 : 1 7 6 ] ;31 cte1 = 0 ; c te2 = 7 ; c t e = cte2 # cte1 ;32 scc = load ? c te : s i [ 1 7 7 : 2 8 7 ] ;33 r_s = ( load | nextt | r_cnt ) ?34 ( scc # sbb # saa ) : r_s ;35 so0 = r_s ;36 r_cnt = load ? 36 : ( r_cnt ? ( r_cnt − 1) : r_cnt ) ;37 ready = ( r_cnt == 0) & (~ load ) ;38 }39 }40 hardwired h_trivium_prng ( trivium_prng ) {run ; }

D.2 MESSAGE_ACCUMUL

1 dp RAM_mrec_shell ( in r e s e t : ns (1 ) ;2 in empty : ns (1 ) ;

102

D.2. MESSAGE_ACCUMUL

3 in data_in : ns (32) ;4 in data_in_valid : ns (1 ) ;5 out data_out : ns (32) ;6 out data_out_valid : ns (1 ) ) {7 sig addressext1 , addres sext2 : ns (9 ) ;8 sig wr1 , rd1 , wr2 , rd2 , setempty : ns (1 ) ;9 sig idataext , odata1 , odata2 : ns (36) ;

10 use RAM_mrec( addressext1 , wr1 , rd1 , idataext , odata1 ) ;11 use RAM_mrec2( addressext2 , wr2 , rd2 , idataext , odata2 ) ;12 reg r_ram1_rnw : ns (1 ) ;13 reg r_address , r_address_d : ns (6 ) ;14 reg r_data_in : ns (32) ;15 reg r_data_in_valid : ns (1 ) ;16 reg r_reset , r_empty , r_empty2 : ns (1 ) ;17 sig dummyns3 : ns (3 ) ; sig dummyns4 : ns (4 ) ;18 sig address1 , address2 : ns (6 ) ;19 sig i da ta : ns (32) ; sig addres sp lusone : ns (6 ) ;20 sfg run {21 addres sp lusone = ( r_address == 54) ? 0 : ( r_address

+ 1) ;22 r_address = ( data_in_valid | r_empty ) ?

addres sp lusone : 0 ;23 r_address_d = r_address ;24 r_data_in = data_in ;25 r_data_in_valid = data_in_valid ;26 dummyns3 = 0 ; dummyns4 = 0 ;27 addres sext1 = dummyns3 # address1 ;28 addres sext2 = dummyns3 # address2 ;29 ida taex t = dummyns4 # idata ;30 address1 = r_ram1_rnw ? r_address : r_address_d ;31 address2 = r_ram1_rnw ? r_address_d : r_address ;32 rd1 = r_ram1_rnw & ( data_in_valid | r_empty ) ;33 rd2 = (~r_ram1_rnw) & ( data_in_valid | r_empty ) ;34 wr2 = r_ram1_rnw & r_data_in_valid ;35 wr1 = (~r_ram1_rnw) & r_data_in_valid ;36 idata = r_data_in ^ ( r_rese t ? 0 : ( r_ram1_rnw ?

odata1 [ 0 : 3 1 ] : odata2 [ 0 : 3 1 ] ) ) ;37 r_rese t = ( r_address_d == 54) ?38 ( r e s e t | 0) : ( r_rese t | r e s e t ) ;39 setempty = ( r_address_d == 54) ?40 ( empty | 0) : ( r_empty | empty ) ;41 r_empty = setempty ; r_empty2 = r_empty ;42 r_ram1_rnw = ( r_address_d == 54) ?43 (~r_ram1_rnw) : r_ram1_rnw ;44 data_out = r_ram1_rnw ?

103

D. Matrixbouwblokken

45 ( odata1 [ 0 : 3 1 ] ) : ( odata2 [ 0 : 3 1 ] ) ;46 data_out_valid = r_empty & ( r_empty2 ) ;47 }48 }49 hardwired h_RAM_mrec_shell (RAM_mrec_shell ) { run ; }

104

Bibliografie

[1] J.-P. Aumasson, L. Henzen, W. Meier en Ra. C.-W. Phan, SHA-3 proposalBLAKE, NIST (2008).

[2] D. Bailey, D. Coffin, A. Elbirt, J. Silverman, en A. Woodbury, NTRU inConstrained Devices, In Cryptographic Hardware and Embedded Systems 2162(2001), 262–272.

[3] D. J. Bernstein, T. Lange en C. Peters, Attacking and Defending the McElieceCryptosystem, In PQCrypto 5299 (2008), 31–46.

[4] G. Bertoni, J. Daemen, M. Peeters en G. van Assche, KECCAK sponge functionfamily main document, Version 1.2 (2009).

[5] B. Biswas en N. Sendrier, McEliece Cryptosystem Implementation: Theory andPractice, Post-Quantum Cryptography 5299 (2008): 47–62.

[6] A. Bogdanov, L. Knudsen, G. Leander, C. Paar, A. Poschmann, M. Robshaw,Y. Seurin en C. Vikkelsoe, PRESENT: An Ultra-Lightweight Block Cipher,Proceedings of Cryptographic Hardware and Embedded Systems, Lecture Notesin Computer Science 4727 (2007), 450–466.

[7] Certicom, SEC 2: Recommended Elliptic Curve Domain Parameters, Version1.0 (2000), www.secg.org/download/aid-386/sec2_final.pdf

[8] H. Chen, G. Chen en J. Li, The generalized Goertzel algorithm and its parallelhardware implementation, Science in China Series A: Mathematics (2008), 37–41.

[9] R. Chien, Cyclic decoding procedures for Bose- Chaudhuri-Hocquenghem codes,IEEE Trans. Information Theory 10 (1964), 357–363.

[10] N. Courtois, M. Finiasz en N. Sendrier, How to Achieve a McEliece-BasedDigital Signature Scheme, In Advances in Cryptology - ASIACRYPT 2001 2248(2001): 157–174.

[11] C. De Cannière en B. Preneel, TRIVIUM Specifications, eS-TREAM, ECRYPTStream Cipher Project, Report 2005/030 (2005),http://www.ecrypt.eu.org/stream.

105

Bibliografie

[12] C. De Cannière, O. Dunkelman en M. Knez̃ević, KATAN & KTANTAN - AFamily of Small and Efficient Hardware-Oriented Block Ciphers, Lecture Notesin Computer Science 5747 (2009), 272–288.

[13] W. Diffie en M. Hellman, New Directions in Cryptography, IEEE Transactionson Information Theory 22(1976), 644–654.

[14] R. Durstenfeld, Algorithm 235: Random permutation, Communications of theACM 7 (1964): 420.

[15] eBACS: ECRYPT Benchmarking of Cryptographic Systems,http://bench.cr.yp.to/results-encrypt.html, (laatst nagekeken op 02/11/2008).

[16] T. Eisenbarth, T. Güneysu, S. Heyse en C. Paar, MicroEliece: McEliece forEmbedded Devices In Proceedings of CHES 2009, LNCS. Springer (2009).

[17] D. Engelbert, R. Overbeck en A. Schmidt, A summary of McEliece-type cryp-tosystems and their security, Cryptology ePrint Archive: Report 162 (2006).

[18] J. Fan, Hardware Evaluation of The Hash Function Hamsi, (2009).

[19] M. Feldhofer, Comparison of Low-Power Implementations of Trivium and Grain,State of the Art of Stream Ciphers Workshop (2007).

[20] S. Fedorenko en P. Trifonov, Finding Roots of Polynomials Over Finite Fields,IEEE Trans. Communications 30 (2002), 1709–1711.

[21] M. Feldhofer, J. Wolfkerstorfer en Vincent Rijmen, AES implementation on agrain of sand, IEE Proceedings of Information Security 152 (2005), 13–20.

[22] K. Gaj, G. Southern en R. Bachimanchi, Comparison of hardware performanceof selected Phase II eSTREAM candidates, (2007).

[23] S. Gao en D. Panario Tests and Constructions of Irreducible Polynomials overFinite Fields Foundations of computational mathematics (1997), 346–361.

[24] T. Güuneysu, C. Paar en J. Pelzl, Special-Purpose Hardware for Solving the El-liptic Curve Discrete Logarithm Problem, ACM Transactions on ReconfigurableTechnology and Systems (2008), 1–21.

[25] G. Gaubatz, J. Kaps, and B. Sunar, Public key cryptography in sensor networks –revisited, In 1st European Workshop on Security in Ad-Hoc and Sensor NetworksESAS2004 (2004).

[26] Generate Primitive and Irreducible Polynomials, (laatst nagekeken op10/10/2006), http://www.theory.cs.uvic.ca/ cos/gen/poly.html.

[27] GEZEL Main Page, (laatst nagekeken op 29/09/2009)http://rijndael.ece.vt.edu/gezel2/index.php/Main_Page.

106

Bibliografie

[28] Helion Technology Inc., Modular ExponentiationCore Family for Xilinx FPGA Data Sheet (2008),http://www.heliontech.com/downloads/modexp_xilinx_datasheet.pdf.

[29] J. Hoffstein, J. Pipher en J. Silverman, NTRU: A Ring-Based Public KeyCryptosystem, Lecture Notes in Computer Science 1423 (1998), 267–288.

[30] D. Hong, J. Sung, S. Hong, J. Lim, S. Lee, B. Koo, C. Lee, D. Chang, J. Lee, K.Jeong, H. Kim, J. Kim en S. Chee, HIGHT: A New Block Cipher Suitable forLow-Resource Device, Lecture Notes in Computer Science 4249 (2006), 46–59.

[31] K. Huber, Taking pth Roots Modulo Polynomials over Finite Fields, Designs,Codes and Cryptography 28 (2003), 303–311.

[32] D. Hwang, M. Chaney, S. Karanam, N. Ton en K. Gaj, Comparison of FPGA-Targeted Hardware Implementations of eSTREAM Stream Cipher Candidates,(SASC 2008).

[33] N. Jachimiec, N. Iliev en J. Stine, Strategies for VLSI Implementations of FiniteField Inversion Algorithms, Circuits and Systems 2 (2005), 1589–1592.

[34] M. Kasper, S. Kumar, K. Lemke-Rust en C. Paar, A Compact Implementationof Edon80, eSTREAM, ECRYPT Stream Cipher Project, Report 57 (2006)

[35] P. Kitsos en A. Skodras, On the Hardware Implementation of the MUGI Pseu-dorandom Number Generator, In proc. of the Fifth International Symposiumon Communications Systems, Networks and Digital Signal Processing (CSND-SPŠ2006), 19–21.

[36] P. Kitsos, N. Sklavos, M.D. Galanis en O. Koufopavlou, 64-bit Block ciphers:hardware implementations and comparison analysis, Computers & ElectricalEngineeringVolume 30 (2004), 593–604.

[37] K. Kobayashi, N. Takagi en K. Takagi, An Algorithm for Inversion in GF (2m)Suitable for Implementation Using a Polynomial Multiply Instruction on GF (2),18th IEEE Symposium on Computer Arithmetic (ARITH 2007).

[38] D. Lay, Linear Algebra and Its Applications 3rd Edition, Pearson (2006).

[39] R. Lidl en H. Niederreiter, Introduction to finite fields and their applications,Cambridge University Press (1986).

[40] C. Lim en T. Korkishko, mCrypton Ů A Lightweight Block Cipher for Securityof Low-Cost RFID Tags and Sensors, Lecture Notes in Computer Science 3786(2005), 243–258.

[41] R. J. McEliece, A Public-Key Cryptosystem Based On Algebraic Coding Theory,Deep Space Network Progress Report 44 (1978), 114–116.

107

Bibliografie

[42] Anoop MS, Elliptic Curve Cryptography – An Implementation Tutorial,http://www.dkrypt.com/home/ecc (2007).

[43] D. Panario en A. Viola, Analysis of Rabin’s Polynomial Irreducibility Test,Lecture Notes in Computer Science 1380 (1998)

[44] N. Patterson, The algebraic decoding of Goppa codes, IEEE Trans. InformationTheory 21 (1975), 203–207.

[45] PicoBlaze User Resources, http://www.xilinx.com/ipcenter/processor_central/picoblaze/picoblaze_user_resources.htm

[46] J. Rabaey, A. Chandrakasan en B. Nikolic, Digital Integrated Circuits SecondEdition, Prentice Hall (2002).

[47] R. Rivest, A. Shamir en L. Adleman, A Method for Obtaining Digital Signaturesand Public-Key Cryptosystems, Communications of the ACM 21 (1978), 120–126.

[48] F. Rodriguez-Henriquez, G. Morales-Luna en J. Lopez-Hernandez, Low Com-plexity Bit-Parallel Square Root Computation over GF (2m) for all Trinomials,IEEE Trans. Computers 57 (2008), 472–480.

[49] P. Schaumont, A Practical Introduction to Hardware/Software Codesign,Springer (2010)

[50] P. Shor, Polynomial-Time Algorithms for Prime Factorization and DiscreteLogarithms on a Quantum Computer, SIAM Journal on Computing 26 (1997),1484–1509.

[51] D. Stefan Hardware Framework for the Rabbit Stream Cipher, Inscrypt (2009).

[52] S. Tillich. Hardware Implementation of the SHA-3 Candidate Skein, IACREprint report 159 (2009).

[53] W. Trappe en L. Washington, Introduction to Cryptography with Coding Theory,Prentice Hall (2002).

[54] V. Umaña en G. Leander, Practical Key Recovery Attacks On Two McElieceVariants, (2009).

[55] T. Voigt en G. Ziegle, Singular 0/1-Matrices, and the Hyperplanes Spanned byRandom 0/1-Vectors, Combinatorics, Probability and Computing archive 15(2006): 463–471.

[56] J. von zur Gathen en J. Gerhard, Modern Computer Algebra, Cambridge Univ.Press (2003).

[57] H. Wu, Bit-Parallel Finite Field Multiplier and Squarer Using Polynomial Basis,IEEE Trans. Computers 51 (2002), 750–758.

108

Bibliografie

[58] H. Wu, Bit-Parallel Polynomial Basis Multiplier for New Classes of Finite Fields,IEEE Trans. Computers 57 (2008), 1023–1031.

[59] C. Yao, Theory and applications of trapdoor functions, In Proceedings of the23rd IEEE Symposium on Foundations of Computer Science (1982)

109

Documents

Een efﬁciënte hardware-implementatie van het McEliece