Az IDEA kriptoalgoritmus hardveres szintézise

Az IDEA kriptoalgoritmus hardveres szintézise . Az IDEA egy szimmetrikus blokk adattitkosítási algoritmus . 2019-ben az IDEA megbízható titkosítási algoritmus a sikeres lineáris kriptoanalitikus támadások hiánya miatt . Használata olyan kritikus alkalmazásokban, mint a katonai, vagy a PGP titkosítási szoftvercsomagban való használata hatékony, rendkívül biztonságos és helyes hardvermegvalósítást igényel.

Az IDEA megbízhatósága

B. Schneier [1] és A. Tanenbaum [2] az IDEA-t az egyik legbiztonságosabb kriptográfiai algoritmusnak tartja. Valójában nincsenek sikeres lineáris kriptoanalitikus támadások az IDEA-val szemben, és az IDEA-ban nincsenek ismert algebrai gyengeségek, kivéve azokat, amelyeket J Daemen [3] fedezett fel . Yoan Dimen a támadást egy 251 gyenge kulcsból álló osztály használatával hajtotta végre a titkosítás során, megkönnyítve a kulcs felfedezését és visszaállítását. Mivel azonban nagyszámú lehetséges kulcs létezik, ez az eredmény nem befolyásolja a titkosítás gyakorlati biztonságát a megadott titkosításhoz.

A múltkori hardver implementációk

Ennek a kriptográfiai algoritmusnak a hardveres megvalósítása az aktív fejlesztés területe volt.

Az alábbiakban bemutatjuk a leggyakoribb megvalósításokat:

Bemutatta az FPGA mag megvalósítását az IDEA számára [4] . Az IDEA megvalósításához egy egymagos modullal rendelkező rendszert használtak, amit Xilinx FPGA -val hajtottak végre .

Az IDEA nagy teljesítményű megvalósítását párhuzamos és soros architektúrák felhasználásával is vizsgálták [6] . Xilinx Virtex XCV300-6 és XCV1000-6 FPGA-kat használtak a teljesítmény értékelésére és elemzésére.

A [7] hivatkozás bemutatta az SRC-6E és a HC-36 általános célú számítógépek IDEA megvalósításának összehasonlítását.

IDEA megvalósítása

A következő megvalósítás Ali E. Abdallah és Issam W. Damaj [8] munkája .

Pontosítás: a folyam az értékek szekvenciális átadásának módszere. Ez egy üzenetsorozatot jelent egy csatornában, ahol minden üzenet más értéket képvisel. Feltételezve, hogy az adatfolyam befejeződött, az utolsó érték elküldése után a rendszer az átvitel végét (EOT) jelenti.

Tekintsük az IDEA algoritmust három fő blokknak. Ezeknek a blokkoknak a globális nézete a titkosítást (vagy dekódolást) 2 bemenettel, egy privát kulccsal és nyílt szöveggel (vagy titkosított szöveggel) és egy titkosított (vagy nyílt szövegű) kimenettel rendelkező blokkként jeleníti meg. A fennmaradó két blokk a titkosítási és visszafejtési alszakasz generálása. Titkosítási alszekciók generálása esetén a blokk elfogadja a kívánt alszekciók bejövő és kimeneti titkos kulcsait . A decryptionsubkeys generátor generált titkosítási alkulcsokat és visszafejtési kulcsokat ad ki. Határozunk meg néhány típust, amelyeket a következő specifikációban használunk (A következő kód HDL -ben van írva ):

type Private = [ Bool ] type SubKey = Int típus Plaintext = [ Int ] type Ciphertext = [ Int ] modVal = 65536

Az IDEA alapvető építőkövei

• Bitenkénti XOR

• 16 bites egész számok hozzáadása modulo 65536 ( )

• Szorozzuk meg a 16 bites egész számokat modulo 65537 ( ), ahol a bemeneti nullák teljes blokkja .

Kulcsgenerálás

Egy 128 bites titkosítási kulcsból 52 db 16 bites alkulcs jön létre. A generálási algoritmus a következő:

• Az első nyolc alkulcsot közvetlenül a kulcsból választja ki úgy, hogy a kulcsot (128 bites lista) nyolc egyenlő hosszúságú (16 bites) szegmensre osztja.

• 25 bites pozíciók körkörös eltolása kerül alkalmazásra. az előző lépés kulcsához, majd nyolc alkulcsot nyer ki.

• Ezt az eljárást addig ismételjük, amíg mind az 52 alkulcs létre nem jön, azaz 8-szor és 4 dedikált kulcs az utolsó szakaszban.

A következő specifikációban az alkulcsok  generálása a generateEncSubKeys függvény, ez a funkció egy titkosítási kulcsot vesz be bemenetként, és egy 52 16 bites alkulcsot tartalmazó listát ad ki. Minden műszakhoz előállítja a megfelelő alkulcsokat a generateSubKeys függvény segítségével. A generált kulcsok ezután egy listába kerülnek. Az 52 alkulcsot ezután kivonja a listából, és az egyes alkulcsokat képviselő 16 elemű bool-listával egyenértékű egész számokká konvertálja. Az átalakítás a btoi függvény segítségével történik:

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

Az összes eltolt billentyűt a keyRotation függvény határozza meg, amely ismételten előállítja azokat. Ez a függvény egy ismétlődő polimorf függvényt használ , amely egy f függvényt és egy xs listát vesz fel, és ismételten alkalmazza az f függvényt xs-re. Ebben az esetben ismételten 25 bites lépésekben adja vissza a kulcsot. Ezért az értékek 0, 25, 50, 75, 100, 125 lesznek:

keyRotation  :: Private -> Bool keyRotation key = take 8 ( ismétlődő ( Shift 25 ) gomb ) ismételve  :: ( a -> a ) -> a -> [ a ] > repeated fx = x: ismételt f ( f x ) Shift  : : Int -> [ a ] ​​​​-> [ a ] ​​Shift n gomb = ( n gomb ledobása ) ++ ( n gomb levétele )

Ha az eltolt kulcsokból 16 bites alkulcsokat szeretne előállítani, alkalmazza a generateEncSubKeys függvényt az eltolt kulcsok listáján szereplő generSubKeys függvényre. A generateSubKeys függvény segs-eket használ, amely n allistát választ ki egy xs listából:

generSubKeys  :: Private -> [ SubKey ] generateSubKeys key = segs 16 key segs  :: Int -> [ a ] ​​​​-> a segs n [] = [] segs n xs = ( take n xs ) : segs n ( drop n xs )

Végül a szükséges alkulcsokat 6 elemből álló listákba csomagoljuk egy függvénycsomag segítségével:

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

Dekódolás

A titkosítás létrehozása után fontolja meg a visszafejtés létrehozását, ahol minden visszafejtési alszakasz az egyik titkosítási alszakasz függvénye. A titkosítási és visszafejtési kulcsok közötti kapcsolatot a generateDecSubKeys függvény határozza meg. Ezt a funkciót úgy hajtja végre, hogy a függvényt leképezi egy előkészített indexlistára. Az execute függvény az addInv és a mulInv függvényeket használja, amelyek az additív és a multiplikatív inverznek felelnek meg. Ez a funkció magasabb rendű függvényeket is használ, amelyek egy függvénylistát és egy értéklistát vesznek fel, és alkalmazzák (az Apply függvény segítségével) az első lista minden egyes funkcióját a második lista megfelelő értékére (a zipWith magasabb rendű függvény használatával) :

generateDecSubKeys  :: [ SubKey ] -> [ SubKey ] generateDecSubKeys eKeys = vegye 52 ( foldr1 ( ++ ) ( map perform index )) , ahol indexek = mapWith fs ( térkép fordított ( reverse [ l | l < - [ 0 ... 51 ]]))) f1 ( xs ) = eltolás 2 xs f2 ( xs ) = zipWith ( + ) ( másolás ( xs !! 2 ) 6 ) [ 0 , 2 , 1 , 3 , - 2 , - 1 ] f3 = idfs = [ f1 , f2 , f2 , f2 , f2 , f2 , f2 , f2 , f3 ] perform ( as ) = mapWith [ mulInv , addInv , addInv , mulInv , id , id ]( zipWith ( !! ) ( 6 másolat e ) ) as ) másolás :: a -> Int -> [ a ] ​​​​másolat x n = [ x | én <- [ 1. . n ]] térképWith :: [( a -> b )] -> [ a ] ​​​​-> [ b ] mapWith fs = zipWith ( alkalmazni ) fs alkalmazni :: ( a -> b ) -> a -> b alkalmazni f = f      

Adunk egy additív inverz aritmetikai műveletet (modulo ) és egy multiplikatív inverz aritmetikai műveletet (modulo ), ezek a műveletek az addInv és mulInv függvények. Az addInv függvény egyszerűen beír egy számot, amelyet ki kell vonni a modulo értékéből:

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

A multiplikatív inverz aritmetikai művelet kiszámításához a kiterjesztett euklideszi algoritmust [9] használjuk . A funkcionális specifikáció így néz ki:

mulInv  :: Int -> IntmulInv 0 = 0 mulInv b = if ( y < 0 ) then (( modVal + 1 ) + y ) else ( y ) ahol y = ( kiterjesztettEucA ( modVal + 1 ) b ) !! 2 kiterjesztettEucA :: Int -> Int -> [ Int ] extendedEucA a b | b == 0 = [ a , 1 , 0 ] | egyébként = iterateSteps [ a , b , 0 , 1 , 1 , 0 ] iterateSteps ls = if (( ls [ 1 ]) > 0 ) then ( iterateSteps s2 ) else ([( ls [ 0 ]), ( ls [ 3 ] ), ( ls [ 5 ])]) , ahol s1 = ( 1. lépés ls ) s2 = ( 2. lépés [( 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 ]))] ahol q = div ( ls1 [ 0 ]) ( ls1 [ 1 ) ]) step2 :: [ Int ] -> [ Int ] step2 ls1 = [( ls1 [ 0 ]), ( ls1 [ 1 ]), ( ls1 [ 3 ]), ( ls1 [ 2 ]), ( ls1 [ 5 ] ), ( ls1 [ 4 ])]

Teljesítményelemzés és értékelés

A különféle titkosítási (dekódolási) konstrukciók eredményei a teljesítmény változását tükrözik. Az első teszt a leggyorsabb, 21,33 Gbps maximális átviteli sebességgel (átlagos átviteli sebesség 21,5 Mbps), amelyet véletlenszerű bemeneti vektorok tesztelésekor figyeltek meg az alábbi kulcsokkal: {1, 2, 3, 4, 5, 6, 7, nyolc}. A második teszt, amely a körök egymás utáni végrehajtásának felel meg, a várt leglassabb átviteli sebességgel rendelkezik (maximális átviteli sebesség 5,82 Gbps és átlagos átviteli sebesség 19,53 Mbps). Érdemes megjegyezni, hogy a moduláris aritmetikai műveletek különböző megvalósításai jelentősen befolyásolják az IDEA teljesítményét.

Összehasonlítás más megvalósításokkal

A Xilinx FPGA -t használó megvalósítás (Davor Runje és Mario Kovač) sokkal gyengébb teljesítményt nyújt, ez a PCI -nyílásokban lévő külön tápegység használatának is köszönhető (az I / O tápvezetékek és a bővítőkártyák fő logikája elkülönül egymástól elkerülje a vezérlő sérülését).

KH Tsoi, PHW Leong bemutatott egy nagyobb teljesítményű megvalósítást a Xilinx Virtex XCV300-6 FPGA alapján. Ám az átviteli sebesség ismét nem volt a legmagasabb szinten, és nagyságrendileg elmaradt Ali E. Abdallah és Issam W. Damaj megvalósításától, MHz, míg a bites soros implementáció 600 Mbps-ot kínál 150 MHz-en. Az XCV1000-6 készüléken a bitpárhuzamos és bitsoros implementációk számított teljesítménye 5,25 Gb/s, illetve 2,40 Gb/s [10] .

Allen Michalski, Kris Gaj és Tarek El-Ghazawi 2,5 MB/s - Crypto++ feldolgozási sebességet értek el. Az SRC platform hardveres feldolgozási sebessége 18,5-szer gyorsabb egyedi adattömbök esetén, és körülbelül 24-szer gyorsabb folyamatos tömbfolyam esetén.

Jegyzetek

  1. ↑ Anthony J. Farrell. Prado, Martial. Gyakorlati spanyol nyelvtan: Öntanítási útmutató. New York: John Wiley & Sons, 1983; Prado, Martial. További gyakorlati spanyol nyelvtan: Öntanítási útmutató. New York: John Wiley & Sons, 1984 Prado, Marcial. Gyakorlati spanyol nyelvtan: Öntanítási útmutató. New York: John Wiley & Sons, 1983. o. viii, 360; Prado, Martial. További gyakorlati spanyol nyelvtan: Öntanítási útmutató. New York: John Wiley & Sons, 1984. o. vi, 378.  Canadian Modern Language Review. — 1985-01. - T. 41 , sz. 3 . – S. 587–588 . - ISSN 1710-1131 0008-4506, 1710-1131 . - doi : 10.3138/cmlr.41.3.587 .
  2. ↑ A. Tanenbaum. számítógépes hálózatok. Prentice Hall, Upper Saddle River, NJ, harmadik kiadás, 1997
  3. ↑ J. Daemen, R. Govaerts és J. Vandewalle. Gyenge kulcsok az IDEA-hoz. Springer-Verlag, 224-231. oldal, 1994
  4. ↑ D. Runje és M. Kovac. Univerzális erős titkosítású FPGA mag megvalósítás. A Proceedings of Design-ban Aautomatizálás és Test Európában, 923-924. oldal, 1998
  5. ↑ Kompromisszumok az IDEA nemzetközi adattitkosítási algoritmus párhuzamos és soros megvalósításaiban .
  6. ↑ OYH Cheung, KH Tsoi, PHW Leong és Leong képviselő. Kompromisszumok az IDEA nemzetközi adattitkosítási algoritmus párhuzamos és soros implementációiban. Előadásjegyzetek a számítástechnikából, 2162:333, 2001
  7. ↑ Allen Michalski, Kris Gaj és Tarek El-Ghazawi. Egy IDEA titkosítási kriptorendszer megvalósításának összehasonlítása két általános célú újrakonfigurálható számítógépen. In Field-Programmable Logic and Applications: 13th International Conference, FPL, Lecture Notes in Computer Science, 204-219 oldal, Lisszabon – Portugália, 2003. Springer
  8. ↑ Az IDEA kriptográfiai algoritmus újrakonfigurálható hardveres szintézise Ali E. ABDALLAH és Issam W. DAMAJ Számítástechnikai Kutatóintézet, Egyesült Királyság
  9. ↑ Jean-Luc Beuchat. Moduláris szorzás az IDEA blokk titkosítás FPGA megvalósításához. Ed Deprettere, Shuvra Bhattacharyya, Joseph Cavallaro, Alain Darte és Lothar Thiele, szerkesztők, Proceedings of the 14. IEEE International Conference on Application-Specific Systems, Architectures, and Processors, 412-422. oldal. IEEE Computer Society, 2003
  10. ↑ Az IDEA nemzetközi adattitkosítási algoritmus párhuzamos és soros megvalósításainak cseréje .