Hårdvarusyntes av IDEA-kryptoalgoritm

Hårdvarusyntes av IDEA -krypteringsalgoritmen . IDEA är en symmetrisk blockdatakrypteringsalgoritm . _ För 2019 är IDEA en pålitlig krypteringsalgoritm på grund av bristen på framgångsrika linjära kryptoanalytiska attacker . Dess användning i kritiska applikationer som militären eller användning i PGP -krypteringsmjukvarupaketet kräver en effektiv, mycket säker och korrekt hårdvaruimplementering.

Tillförlitligheten hos IDEA

B. Schneier [1] och A. Tanenbaum [2] anser att IDEA är en av de säkraste kryptografiska algoritmerna som finns. Faktum är att det inte finns några framgångsrika linjära kryptoanalytiska attacker på IDEA, och det finns inga kända algebraiska svagheter i IDEA förutom den som upptäckts av J Daemen [3] . Yoan Dimen utförde attacken med en klass av 251 svaga nycklar under kryptering, vilket gjorde det lättare att upptäcka och återställa nyckeln. Men eftersom det finns ett stort antal möjliga nycklar, påverkar detta resultat inte den praktiska säkerheten för chifferet för den tillhandahållna krypteringen.

Hårdvaruimplementationer från förr

Hårdvaruimplementeringen av denna kryptografiska algoritm har varit ett område för aktiv utveckling.

Nedan är de vanligaste implementeringarna:

Presenterade implementeringen av FPGA-kärnan för IDEA [4] . De använde ett system med en enda kärnmodul för att implementera IDEA, vilket gjordes med hjälp av en Xilinx FPGA .

En högpresterande implementering av IDEA undersöktes med både parallella och seriella arkitekturer [6] . De använde Xilinx Virtex XCV300-6 och XCV1000-6 FPGA för prestandautvärdering och analys.

Referens [7] presenterade en jämförelse av IDEA-implementeringen mellan SRC-6E och HC-36 allmänna datorer.

Implementering av IDEA

Följande implementering är arbetet av Ali E. Abdallah och Issam W. Damaj [8] .

Förtydligande: en ström är en metod för att sekventiellt skicka värden. Det innebär en sekvens av meddelanden i en kanal, där varje meddelande representerar ett annat värde. Förutsatt att strömmen avslutas, efter att det sista värdet har sänts, kommer ett slut på sändningen (EOT) att rapporteras.

Betrakta IDEA- algoritmen som tre huvudblock. En global vy av dessa block skulle visa kryptering (eller dekryptering) som ett block med 2 ingångar, en privat nyckel och klartext (eller chiffertext) och en chiffertext (eller klartext). De två återstående blocken är genereringen av krypterings- och dekrypteringsundersektionerna. I fallet med generering av krypteringsundersektioner kommer blocket att acceptera privata nycklar som kommer in och matar ut de önskade undersektionerna. Generatorn för dekrypteringsundernycklar kommer att injicera genererade krypteringsundernycklar och mata ut dekrypteringsnycklar. Låt oss definiera några typer som kommer att användas i följande specifikation (Följande kod är skriven i HDL ):

typ Privat = [ Bool ] typ SubKey = Int typ Plaintext = [ Int ] typ Chiffertext = [ Int ] modVal = 65536

Grundläggande byggstenar inom IDEA

• Bitvis XOR

• Lägga till 16-bitars heltal modulo 65536 ( )

• Multiplicera 16-bitars heltal modulo 65537 ( ), där hela blocket av ingångsnollor behandlas som .

Nyckelgenerering

52 16-bitars undernycklar genereras från en 128-bitars krypteringsnyckel. Genereringsalgoritmen är som följer:

• De första åtta undernycklarna väljs direkt från nyckeln genom att dela upp nyckeln (128-bitars lista) i åtta lika långa segment (16-bitars)

• En cirkulär förskjutning av 25-bitars positioner tillämpas. till nyckeln för föregående steg, och sedan extraheras åtta undernycklar.

• Denna procedur upprepas tills alla 52 undernycklar har genererats, dvs 8 gånger och 4 dedikerade nycklar i slutskedet.

I följande specifikation är genereringen av undernycklar  funktionen generEncSubKeys, denna funktion tar en krypteringsnyckel som indata och matar ut en lista med 52 16-bitars undernycklar. Den genererar motsvarande undernycklar för varje skift med hjälp av funktionen genereraSubKeys. De genererade nycklarna kombineras sedan till en lista. De 52 undernycklarna extraheras sedan från listan och konverteras till heltal som motsvarar boollistan med 16 element som representerar varje undernyckel. Konverteringen görs med hjälp av btoi-funktionen:

generEncSubKeys  :: Privat -> [ SubKey ] generEncSubKeys nyckel = map ( btoi ) ( take 52 ( foldr1 ( ++ ) ( map generateSubKeys ( take 8 ( keyRotation key )))))

Alla förskjutna tangenter bestäms av keyRotation-funktionen, som upprepade gånger genererar dem. Denna funktion använder en repeterande polymorf funktion som tar en funktion f och en lista med xs och upprepade gånger tillämpar funktionen f på xs. I det här fallet returnerar den nyckeln upprepade gånger i 25-bitarssteg. Därför kommer värdena att vara 0, 25, 50, 75, 100, 125:

keyRotation  :: Privat -> Bool keyRotation key = ta 8 ( upprepad ( shift 25 ) tangent ) upprepad  :: ( a -> a ) -> a -> [ a ] ​ repeterad fx = x: upprepad f ( f x ) shift  : : Int -> [ a ] ​​-> [ a ] ​​shift n - tangent = ( släpp n - tangent ) ++ ( ta n - tangent )

För att generera 16-bitars undernycklar från de skiftade nycklarna, använd funktionen generEncSubKeys på funktionen genereraSubKeys i listan över skiftade nycklar. GenereraSubKeys-funktionen använder segs, som väljer n underlistor från en lista xs:

generSubKeys  :: Private -> [ SubKey ] generSubKeys key = segs 16 key segs  :: Int -> [ a ] ​-> a segs n [] = [] segs n xs = ( ta n xs ) : segs n ( släpp n xs )

Slutligen packas de nödvändiga undernycklarna i listor med 6 element i ett med hjälp av ett funktionspaket:

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

Dekryptering

Efter att ha genererat krypteringen, överväg att generera dekrypteringen, där varje dekrypteringsundersektion är en funktion av en av krypteringsundersektionerna. Relationen mellan krypterings- och dekrypteringsnycklarna definieras i funktionen generDecSubKeys. Denna funktion utförs genom att mappa funktionen till en förberedd indexlista. Exekveringsfunktionen använder addInv och mulInv, som motsvarar additiv respektive multiplikativ invers. Den här funktionen använder också funktioner av högre ordning som tar en lista med funktioner och en värdelista och tillämpar (med tillämpningsfunktionen) varje funktion i den första listan på motsvarande värde i den andra listan (med hjälp av den högre ordningen zipWith) :

generDecSubKeys  :: [ SubKey ] -> [ SubKey ] generDecSubKeys eKeys = ta 52 ( foldr1 ( ++ ) ( map perform index )) där index = mapWith fs ( map reverse ( pack ( omvänd [ l | l <- [ 0.. ) 51 ]]))) f1 ( xs ) = skift 2 xs f2 ( xs ) = zipMed ( + ) ( kopia ( xs !! 2 ) 6 ) [ 0 , 2 , 1 , 3 , - 2 , - 1 ] f3 = idfs = [ f1 , f2 , f2 , f2 , f2 , f2 , f2 , f2 , f3 ] utför ( som ) = mapMed [ mulInv , addInv , addInv , mulInv , id , id ]( zipWith ( !! ) ( kopia 6 eKeys ) as ) copy :: a -> Int -> [ a ] ​​copy x n = [ x | i <- [ 1. . n ]] kartaMed :: [( a -> b )] -> [ a ] ​-> [ b ] kartaMed fs = zipMed ( tillämpa ) fs gäller :: ( a -> b ) -> a -> b tillämpas f = f      

Vi definierar en additiv invers aritmetisk operation (modulo ) och en multiplikativ invers aritmetisk operation (modulo ). Dessa operationer är funktionerna addInv och mulInv. AddInv-funktionen anger helt enkelt ett tal för att subtrahera från modulovärdet:

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

För att beräkna den multiplikativa inversa aritmetiska operationen används den utökade euklidiska algoritmen [9] . Funktionsspecifikationen ser ut så här:

mulInv  :: Int -> IntmulInv 0 = 0 mulInv b = if ( y < 0 ) then (( modVal + 1 ) + y ) else ( y ) där y = ( extendedEucA ( modVal + 1 ) b ) !! 2 extendedEucA :: Int -> Int -> [ Int ] extendedEucA a b | b == 0 = [ a , 1 , 0 ] | annars = iterateSteps [ a , b , 0 , 1 , 1 , 0 ] iterateSteps ls = om (( ls [ 1 ]) > 0 ) then ( iterateSteps s2 ) else ([( ls [ 0 ]), ( ls [ 3 ] ), ( ls [ 5 ])]) där s1 = ( steg1 ls ) s2 = ( steg 2 [( ls [ 1 ]), ( s1 [ 1 ]), ( ls [ 2 ]), ( s1 [ 2 ]), ( ls [ 4 ]), ( s1 [ 3 ])]) steg1 :: [ Int ] -> [ Int ] steg1 ls1 = [ q , ( ls1 [ 0 ]) - ( q * ( ls1 [ 1 ])), ( ls1 [ 3 ]) - ( q * ( ls1 [ 2 ])), ( ls1 [ 5 ]) - ( q * ( ls1 [ 4 ]))] där q = div ( ls1 [ 0 ]) ( ls1 [ 1 ]) steg2 :: [ Int ] -> [ Int ] steg2 ls1 = [( ls1 [ 0 ]), ( ls1 [ 1 ]), ( ls1 [ 3 ]), ( ls1 [ 2 ]), ( ls1 [ 5 ] ), ( ls1 [ 4 ])]

Prestandaanalys och utvärdering

Resultaten för olika kryptering (dekryptering) konstruktioner återspeglar förändringen i prestanda. Det första testet är det snabbaste med en maximal genomströmning på 21,33 Gbps (genomsnittlig genomströmning 21,5 Mbps) som noteras vid testning av slumpmässiga indatavektorer med nyckel = {1, 2, 3, 4, 5, 6, 7 , åtta} . Det andra testet, som motsvarar sekventiell exekvering av rundor, har den förväntade långsammaste genomströmningen (maximal genomströmning 5,82 Gbps och genomsnittlig genomströmning 19,53 Mbps). Det är värt att notera att olika implementeringar av modulära aritmetiska operationer avsevärt påverkar IDEA:s prestanda.

Jämförelse med andra implementeringar

Implementeringen med Xilinx FPGA (Davor Runje och Mario Kovač) är mycket sämre i prestanda, detta beror också på användningen av separat strömförsörjning i PCI- platserna (I/O-kraftledningarna och expansionskortens huvudlogik är separerade till förhindra skador på styrenheten).

KH Tsoi, PHW Leong presenterade en mer högpresterande implementering baserad på Xilinx Virtex XCV300-6 FPGA. Men återigen, genomströmningen var inte på den högsta nivån och släpade efter implementeringen av Ali E. Abdallah och Issam W. Damaj med en storleksordning MHz, medan den seriella bitimplementeringen erbjuder 600 Mbps vid 150 MHz. Den beräknade prestandan för bitparallella och bitseriella implementeringar på XCV1000-6-enheten är 5,25 Gb/s respektive 2,40 Gb/s [10] .

Allen Michalski, Kris Gaj och Tarek El-Ghazawi fick resultat på 2,5 MB/s - Crypto++ bearbetningsgenomströmning. Hårdvarubehandlingshastigheten för SRC-plattformen är 18,5 gånger snabbare för enstaka datamatriser och cirka 24 gånger snabbare för en kontinuerlig ström av matriser.

Anteckningar

  1. Anthony J. Farrell. Prado, Martial. Praktisk spansk grammatik: en självlärande guide. New York: John Wiley & Sons, 1983; Prado, Martial. Mer praktisk spansk grammatik: en självlärande guide. New York: John Wiley & Sons, 1984 Prado, Marcial. Praktisk spansk grammatik: en självlärande guide. New York: John Wiley & Sons, 1983. S. viii, 360; Prado, Martial. Mer praktisk spansk grammatik: en självlärande guide. New York: John Wiley & Sons, 1984. S. vi, 378.  Canadian Modern Language Review. — 1985-01. - T. 41 , nej. 3 . — S. 587–588 . - ISSN 1710-1131 0008-4506, 1710-1131 . - doi : 10.3138/cmlr.41.3.587 .
  2. A. Tanenbaum. dator nätverk. Prentice Hall, Upper Saddle River, NJ, tredje upplagan, 1997
  3. J. Daemen, R. Govaerts och J. Vandewalle. Svaga nycklar för IDEA. Springer-Verlag, sid 224-231, 1994
  4. D. Runje och M. Kovac. Universell stark kryptering FPGA kärnimplementering. I Proceedings of Design, Aautomation och Test in Europe, sid 923-924, 1998
  5. Avvägningar i parallella och seriella implementeringar av IDEA för internationella datakrypteringsalgoritmer .
  6. OYH Cheung, KH Tsoi, PHW Leong och MP Leong. Avvägningar i parallella och seriella implementeringar av den internationella datakrypteringsalgoritmen IDEA. Lecture Notes in Computer Science, 2162:333, 2001
  7. Allen Michalski, Kris Gaj och Tarek El-Ghazawi. En implementeringsjämförelse av ett IDEA-krypteringskrypteringssystem på två omkonfigurerbara datorer för allmänt bruk. In Field-Programmable Logic and Applications: 13th International Conference, FPL, Lecture Notes in Computer Science, sid 204-219, Lissabon - Portugal, 2003. Springer
  8. Omkonfigurerbar hårdvarusyntes av IDEA Cryptographic Algorithm Ali E. ABDALLAH och Issam W. DAMAJ Research Institute for Computing, Storbritannien
  9. Jean-Luc Beuchat. Modulär multiplikation för FPGA-implementering av IDEA-blockchifferet. I Ed Deprettere, Shuvra Bhattacharyya, Joseph Cavallaro, Alain Darte och Lothar Thiele, redaktörer, Proceedings of the 14th IEEE International Conference on Application-Specific Systems, Architectures and Processors, sidorna 412-422. IEEE Computer Society, 2003
  10. Avvägningar i parallella och seriella implementeringar av den internationella datakrypteringsalgoritmen IDEA .