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.
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.
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.
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• 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 .
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 6A 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 = fAdunk 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 - aA 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 ])]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.
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.