Hardware syntese af IDEA kryptoalgoritme

Hardwaresyntese af IDEA -kryptoalgoritmen . IDEA er en symmetrisk blokdatakrypteringsalgoritme . _ For 2019 er IDEA en pålidelig krypteringsalgoritme på grund af manglen på vellykkede lineære kryptoanalytiske angreb . Dets brug i kritiske applikationer såsom militæret eller brug i PGP -krypteringssoftwarepakken kræver en effektiv, yderst sikker og korrekt hardwareimplementering.

Pålideligheden af ​​IDEA

B. Schneier [1] og A. Tanenbaum [2] anser IDEA for at være en af ​​de mest sikre kryptografiske algoritmer til rådighed. Faktisk er der ingen vellykkede lineære kryptoanalytiske angreb på IDEA, og der er ingen kendte algebraiske svagheder i IDEA ud over dem, der blev opdaget af J Daemen [3] . Yoan Dimen udførte angrebet ved hjælp af en klasse på 251 svage nøgler under kryptering, hvilket gjorde det nemmere at opdage og gendanne nøglen. Men da der er et stort antal mulige nøgler, påvirker dette resultat ikke den praktiske sikkerhed af chifferen for den tilvejebragte kryptering.

Hardwareimplementeringer fra tidligere år

Hardwareimplementeringen af ​​denne kryptografiske algoritme har været et område med aktiv udvikling.

Nedenfor er de mest almindelige implementeringer:

Præsenterede implementeringen af ​​FPGA-kernen til IDEA [4] . De brugte et system med et enkelt kernemodul til at implementere IDEA, hvilket blev gjort ved hjælp af en Xilinx FPGA .

En højtydende implementering af IDEA blev undersøgt ved brug af både parallelle og serielle arkitekturer [6] . De brugte Xilinx Virtex XCV300-6 og XCV1000-6 FPGA'er til ydelsesevaluering og analyse.

Reference [7] præsenterede en sammenligning af IDEA-implementeringen mellem SRC-6E og HC-36 almindelige computere.

Implementering af IDEA

Følgende implementering er arbejdet af Ali E. Abdallah og Issam W. Damaj [8] .

Præcisering: en strøm er en metode til sekventiel videregivelse af værdier. Det indebærer en sekvens af beskeder i en kanal, hvor hver besked repræsenterer en anden værdi. Forudsat at streamen er afsluttet, vil en afslutning på transmission (EOT) blive rapporteret efter den sidste værdi er blevet transmitteret.

Betragt IDEA- algoritmen som tre hovedblokke. En global visning af disse blokke ville vise kryptering (eller dekryptering) som en blok med 2 input, en privat nøgle og almindelig tekst (eller chiffertekst) og en chiffertekst (eller klartekst) output. De to resterende blokke er genereringen af ​​krypterings- og dekrypteringsundersektionerne. I tilfælde af generering af krypteringsundersektioner vil blokken acceptere private nøgler , der kommer ind og udsender de ønskede undersektioner. Generatoren af ​​dekrypteringsundernøgler vil injicere genererede krypteringsundernøgler og udlæse dekrypteringsnøgler. Lad os definere nogle typer, der vil blive brugt i følgende specifikation (Følgende kode er skrevet i HDL ):

type Privat = [ Bool ] type SubKey = Int type Plaintext = [ Int ] type Ciphertext = [ Int ] modVal = 65536

Grundlæggende byggeklodser i IDEA

• Bitvis XOR

• Tilføjelse af 16-bit heltal modulo 65536 ( )

• Multiplicer 16-bit heltal modulo 65537 ( ), hvor hele blokken af ​​input nuller behandles som .

Nøglegenerering

52 16-bit undernøgler genereres fra en 128-bit krypteringsnøgle. Genereringsalgoritmen er som følger:

• De første otte undernøgler vælges direkte fra nøglen ved at dele nøglen (128-bit liste) i otte segmenter af samme længde (16-bit)

• Et cirkulært skift af 25-bit positioner anvendes. til nøglen til det forrige trin, og derefter udtrækkes otte undernøgler.

• Denne procedure gentages, indtil alle 52 undernøgler er blevet genereret, dvs. 8 gange og 4 dedikerede nøgler i sidste fase.

I den følgende specifikation er genereringen af ​​undernøgler  funktionen generEncSubKeys, denne funktion tager en krypteringsnøgle som input og udsender en liste med 52 16-bit undernøgler. Den genererer de tilsvarende undernøgler for hvert skift ved hjælp af funktionen genererSubKeys. De genererede nøgler kombineres derefter til én liste. De 52 undernøgler ekstraheres derefter fra listen og konverteres til heltal svarende til den 16-elements bool-liste, der repræsenterer hver undernøgle. Konverteringen udføres ved hjælp af btoi-funktionen:

generEncSubKeys  :: Private -> [ Undernøgle ] generEncSubKeys key = map ( btoi ) ( take 52 ( foldr1 ( ++ ) ( map generateSubKeys ( take 8 ( keyRotation key )))))

Alle forskudte taster bestemmes af keyRotation-funktionen, som gentagne gange genererer dem. Denne funktion bruger en gentagende polymorf funktion , der tager en funktion f og en liste af xs og gentagne gange anvender funktionen f til xs. I dette tilfælde returnerer den gentagne gange nøglen i intervaller på 25-bit. Derfor vil værdierne være 0, 25, 50, 75, 100, 125:

keyRotation  :: Privat -> Bool -tastRotationstast = tag 8 ( gentaget ( shift 25 ) tast ) gentaget :: ( a -> a ) - > a -> [ a ] ​​gentaget fx = x: gentaget f ( f x ) skift : : Int -> [ a ] -> [ a ] skift n - tast = ( slip n - tasten ) ++ ( tag n - tasten )    

For at generere 16-bit undernøgler fra de skiftede nøgler skal du anvende funktionen generEncSubKeys på funktionen genererSubKeys på listen over skiftede nøgler. GenererSubKeys-funktionen bruger segs, som vælger n underlister fra en liste xs:

generSubKeys  :: Private -> [ Undernøgle ] genererSubKeys key = segs 16 key segs  :: Int -> [ a ] ​-> a segs n [] = [] segs n xs = ( tag n xs ) : segs n ( slip n xs )

Til sidst pakkes de nødvendige undernøgler i lister med 6 elementer i én ved hjælp af en funktionspakke:

pack  :: [ a ] ​-> a pack = segs 6

Dekryptering

Efter generering af krypteringen kan du overveje at generere dekrypteringen, hvor hver dekrypteringsundersektion er en funktion af en af ​​krypteringsundersektionerne. Forholdet mellem krypterings- og dekrypteringsnøglerne er defineret i funktionen generDecSubKeys. Denne funktion udføres ved at tilknytte funktionen til en forberedt indeksliste. Udfør-funktionen bruger addInv og mulInv, som svarer til henholdsvis additiv og multiplikativ invers. Denne funktion bruger også funktioner af højere orden, der tager en liste over funktioner og en liste over værdier og anvender (ved hjælp af anvende-funktionen) hver funktion i den første liste til den tilsvarende værdi i den anden liste (ved hjælp af højere ordens-funktionen zipWith) :

generDecSubKeys  :: [ Undernøgle ] -> [ Undernøgle ] generDecSubKeys eKeys = take 52 ( foldr1 ( ++ ) ( map perform indexes )) hvor indekser = mapWith fs ( map reverse ( pack ( reverse [ l | l <- [ 0.. 51 ]]))) f1 ( xs ) = skift 2 xs f2 ( xs ) = zipMed ( + ) ( kopi ( xs !! 2 ) 6 ) [ 0 , 2 , 1 , 3 , - 2 , - 1 ] f3 = idfs = [ f1 , f2 , f2 , f2 , f2 , f2 , f2 , f2 , f3 ] udføre ( som ) = kortMed [ mulInv , addInv , addInv , mulInv , id , id ]( zipWith ( !! ) ( kopier eKeys ) ) som ) kopi :: a -> Int -> [ a ] ​​kopi x n = [ x | i <- [ 1. . n ]] kortMed :: [( a -> b )] -> [ a ] ​-> [ b ] kortMed fs = zipMed ( anvend ) fs gælder :: ( a -> b ) -> a -> b gælder f = f      

Vi definerer en additiv invers aritmetisk operation (modulo ) og en multiplikativ invers aritmetisk operation (modulo ) Disse operationer er addInv og mulInv funktionerne. AddInv-funktionen indtaster simpelthen et tal for at trække fra modulo-værdien:

addInv  :: Int -> Int addInv a = modVal - a

For at beregne den multiplikative inverse aritmetiske operation bruges den udvidede euklidiske algoritme [9] . Funktionsspecifikationen ser således ud:

mulInv  :: Int -> IntmulInv 0 = 0 mulInv b = if ( y < 0 ) then (( modVal + 1 ) + y ) else ( y ) hvor y = ( extendedEucA ( modVal + 1 ) b ) !! 2 extendedEucA :: Int -> Int -> [ Int ] extendedEucA a b | b == 0 = [ a , 1 , 0 ] | ellers = iterateSteps [ a , b , 0 , 1 , 1 , 0 ] iterateSteps ls = if (( ls [ 1 ]) > 0 ) then ( iterateSteps s2 ) else ([( ls [ 0 ]), ( ls [ 3 ] ), ( ls [ 5 ])]) hvor s1 = ( step1 ls ) s2 = ( step2 [( ls [ 1 ]), ( s1 [ 1 ]), ( ls [ 2 ]), ( s1 [ 2 ]), ( ls [ 4 ]), ( s1 [ 3 ])]) step1 :: [ Int ] -> [ Int ] step1 ls1 = [ q , ( ls1 [ 0 ]) - ( q * ( ls1 [ 1 ])), ( ls1 [ 3 ]) - ( q * ( ls1 [ 2 ])), ( ls1 [ 5 ]) - ( q * ( ls1 [ 4 ]))] hvor q = div ( ls1 [ 0 ]) ( ls1 [ 1 ]) step2 :: [ Int ] -> [ Int ] step2 ls1 = [( ls1 [ 0 ]), ( ls1 [ 1 ]), ( ls1 [ 3 ]), ( ls1 [ 2 ]), ( ls1 [ 5 ] ), ( ls1 [ 4 ])]

Præstationsanalyse og evaluering

Resultaterne for forskellige kryptering (dekryptering) konstruktioner afspejler ændringen i ydeevne. Den første test er den hurtigste med en maksimal gennemstrømning på 21,33 Gbps (gennemsnitlig gennemstrømning 21,5 Mbps) noteret ved test af tilfældige inputvektorer med nøgle = {1, 2, 3, 4, 5, 6, 7 , otte}. Den anden test, som svarer til sekventiel udførelse af runder, har den forventede langsomste gennemløb (maksimal gennemstrømning 5,82 Gbps og gennemsnitlig gennemstrømning 19,53 Mbps). Det er værd at bemærke, at forskellige implementeringer af modulære aritmetiske operationer påvirker IDEAs ydeevne betydeligt.

Sammenligning med andre implementeringer

Implementeringen ved hjælp af Xilinx FPGA (Davor Runje og Mario Kovač) er meget ringere med hensyn til ydeevne, dette skyldes også brugen af ​​separat strømforsyning i PCI -slots (I/O-strømledningerne og udvidelseskortenes hovedlogik er adskilt til forhindre beskadigelse af controlleren).

KH Tsoi, PHW Leong præsenterede en mere højtydende implementering baseret på Xilinx Virtex XCV300-6 FPGA. Men igen var gennemstrømningen ikke på højeste niveau og haltede efter implementeringen af ​​Ali E. Abdallah og Issam W. Damaj med en størrelsesorden MHz, mens den serielle bitimplementering tilbyder 600 Mbps ved 150 MHz. Den beregnede ydeevne af bitparallelle og bitserielle implementeringer på XCV1000-6-enheden er henholdsvis 5,25 Gb/s og 2,40 Gb/s [10] .

Allen Michalski, Kris Gaj og Tarek El-Ghazawi fik resultater på 2,5 MB/s - Crypto++ behandlingsgennemstrømning. Hardwarebehandlingshastigheden på SRC-platformen er 18,5 gange hurtigere for enkelte dataarrays og omkring 24 gange hurtigere for en kontinuerlig strøm af arrays.

Noter

  1. ↑ Anthony J. Farrell. Prado, Martial. Praktisk spansk grammatik: En selvlærende vejledning. New York: John Wiley & Sons, 1983; Prado, Martial. Mere praktisk spansk grammatik: En selvlærende vejledning. New York: John Wiley & Sons, 1984 Prado, Marcial. Praktisk spansk grammatik: En selvlærende vejledning. New York: John Wiley & Sons, 1983. S. viii, 360; Prado, Martial. Mere praktisk spansk grammatik: En selvlærende vejledning. New York: John Wiley & Sons, 1984. S. vi, 378.  Canadian Modern Language Review. — 1985-01. - T. 41 , no. 3 . — S. 587–588 . - ISSN 1710-1131 0008-4506, 1710-1131 . - doi : 10.3138/cmlr.41.3.587 .
  2. ↑ A. Tanenbaum. computernetværk. Prentice Hall, Upper Saddle River, NJ, tredje udgave, 1997
  3. ↑ J. Daemen, R. Govaerts og J. Vandewalle. Svage nøgler til IDEA. Springer-Verlag, side 224-231, 1994
  4. ↑ D. Runje og M. Kovac. Universal stærk kryptering FPGA-kerneimplementering. I Proceedings of Design, Aautomatisering og Test in Europe, side 923-924, 1998
  5. ↑ Afvejninger i parallelle og serielle implementeringer af den internationale datakrypteringsalgoritme IDEA .
  6. ↑ OYH Cheung, KH Tsoi, PHW Leong og MP Leong. Afvejninger i parallelle og serielle implementeringer af den internationale datakrypteringsalgoritme IDEA. Lecture Notes in Computer Science, 2162:333, 2001
  7. ↑ Allen Michalski, Kris Gaj og Tarek El-Ghazawi. En implementeringssammenligning af et IDEA-krypteringskryptosystem på to genkonfigurerbare computere til generelle formål. In Field-Programmable Logic and Applications: 13th International Conference, FPL, Lecture Notes in Computer Science, side 204-219, Lissabon - Portugal, 2003. Springer
  8. ↑ Rekonfigurerbar hardwaresyntese af IDEA Cryptographic Algorithm Ali E. ABDALLAH og Issam W. DAMAJ Research Institute for Computing, Storbritannien
  9. ↑ Jean-Luc Beuchat. Modulær multiplikation til FPGA-implementering af IDEA-blokchifferet. I Ed Deprettere, Shuvra Bhattacharyya, Joseph Cavallaro, Alain Darte og Lothar Thiele, redaktører, Proceedings of the 14th IEEE International Conference on Application-Specific Systems, Architectures and Processors, side 412-422. IEEE Computer Society, 2003
  10. ↑ Tradeoffs i parallelle og serielle implementeringer af den internationale datakrypteringsalgoritme IDEA .