Sinteza hardware a criptoalgoritmului IDEA

Sinteza hardware a criptoalgoritmului IDEA . IDEA este un algoritm de criptare a datelor bloc simetric . Pentru 2019, IDEA este un algoritm de criptare de încredere din cauza lipsei de atacuri criptoanalitice liniare de succes . Utilizarea sa în aplicații critice, cum ar fi cele militare sau utilizarea în pachetul software de criptare PGP necesită o implementare hardware eficientă, foarte sigură și corectă.

Fiabilitatea IDEA

B. Schneier [1] și A. Tanenbaum [2] consideră IDEA ca fiind unul dintre cei mai siguri algoritmi criptografici disponibili. De fapt, nu există atacuri criptoanalitice liniare de succes asupra IDEA și nu există slăbiciuni algebrice cunoscute în IDEA, altele decât cele descoperite de J Daemen [3] . Yoan Dimen a efectuat atacul folosind o clasă de 251 de chei slabe în timpul criptării, făcând mai ușor de descoperit și recuperat cheia. Cu toate acestea, deoarece există un număr mare de chei posibile, acest rezultat nu afectează securitatea practică a cifrului pentru criptarea furnizată.

Implementări hardware de altădată

Implementarea hardware a acestui algoritm criptografic a fost o zonă de dezvoltare activă.

Mai jos sunt cele mai comune implementări:

Davor Runje și Mario Kovac

A prezentat implementarea nucleului FPGA pentru IDEA [4] . Au folosit un sistem cu un singur modul de bază pentru a implementa IDEA, care a fost realizat folosind un FPGA Xilinx .

KH Tsoi, PHW Leong [5]

O implementare de înaltă performanță a IDEA a fost investigată folosind atât arhitecturi paralele, cât și în serie [6] . Ei au folosit FPGA-uri Xilinx Virtex XCV300-6 și XCV1000-6 pentru evaluarea și analiza performanței.

Allen Michalski, Kris Gaj și Tarek El-Ghazawi

Referința [7] a prezentat o comparație a implementării IDEA între calculatoarele de uz general SRC-6E și HC-36.

Implementarea IDEA

Următoarea implementare este opera lui Ali E. Abdallah și Issam W. Damaj [8] .

Clarificare: un flux este o metodă de transmitere secvențială a valorilor. Implică o secvență de mesaje într-un canal, fiecare mesaj reprezentând o valoare diferită. Presupunând că fluxul este terminat, după ce ultima valoare a fost transmisă, va fi raportat un sfârșit de transmisie (EOT).

Considerați algoritmul IDEA ca trei blocuri principale. O vedere globală a acestor blocuri ar arăta criptarea (sau decriptarea) ca un bloc cu 2 intrări, o cheie privată și text simplu (sau text cifrat) și o ieșire text cifrat (sau text simplu). Cele două blocuri rămase sunt generarea subsecțiunilor de criptare și decriptare. În cazul generării de subsecțiuni de criptare, blocul va accepta cheile private care primesc și scot subsecțiunile dorite. Generatorul de decryptionsubkeys va injecta subchei de criptare generate și va scoate cheile de decriptare. Să definim câteva tipuri care vor fi utilizate în următoarea specificație (Următorul cod este scris în HDL ):

tip Private = [ Bool ] tip SubKey = Tip int Plaintext = [ Int ] tip Ciphertext = [ Int ] modVal = 65536

Blocuri de bază în cadrul IDEA

• XOR pe biți

• Adăugarea numerelor întregi pe 16 biți modulo 65536 ( ) $2^{16}$

• Înmulțiți numere întregi de 16 biți modulo 65537 ( ), unde întregul bloc de zerouri de intrare este tratat ca . $2^{16}-1$ $2^{16}$

Generare cheie

52 de subchei de 16 biți sunt generate dintr-o cheie de criptare de 128 de biți. Algoritmul de generare este următorul:

• Primele opt subchei sunt selectate direct din cheie prin împărțirea cheii (lista pe 128 de biți) în opt segmente de lungime egală (16 biți)

• Se aplică o deplasare circulară a pozițiilor de 25 de biți. la cheia pasului anterior, apoi sunt extrase opt subchei.

• Această procedură se repetă până când toate cele 52 de subchei au fost generate, adică de 8 ori și 4 chei dedicate în etapa finală.

În specificația următoare, generarea de subchei este funcția generateEncSubKeys, această funcție ia o cheie de criptare ca intrare și emite o listă de 52 de subchei pe 16 biți. Acesta generează subcheile corespunzătoare pentru fiecare schimb folosind funcția generateSubKeys. Cheile generate sunt apoi combinate într-o singură listă. Cele 52 de subchei sunt apoi extrase din listă și convertite în numere întregi echivalente cu lista bool de 16 elemente care reprezintă fiecare subcheie. Conversia se face folosind funcția btoi:

generateEncSubKeys :: Private -> [ SubKey ] generateEncSubKeys cheia = hartă ( btoi ) ( ia 52 ( foldr1 ( ++ ) ( harta generateSubKeys ( ia 8 ( keyRotation key )))))

Toate tastele deplasate sunt determinate de funcția keyRotation, care le generează în mod repetat. Această funcție folosește o funcție polimorfă repetată care ia o funcție f și o listă de xs și aplică în mod repetat funcția f la xs. În acest caz, returnează în mod repetat cheia în trepte de 25 de biți. Prin urmare, valorile vor fi 0, 25, 50, 75, 100, 125:

keyRotation :: Private -> Bool keyRotation key = take 8 ( repetat ( shift 25 ) tastă ) repetat :: ( a -> a ) -> a -> [ a ] repetat fx = x: repetat f ( f x ) shift :: Int -> [ a ] -> [ a ] shift n tasta = ( drop n key ) ++ ( take n key )

Pentru a genera subchei pe 16 biți din tastele deplasate, aplicați funcția generateEncSubKeys la funcția generateSubKeys din lista de taste deplasate. Funcția generateSubKeys folosește segs, care selectează n subliste dintr-o listă xs:

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

În cele din urmă, subcheile necesare sunt împachetate în liste de 6 elemente într-una singură folosind un pachet de funcții:

pachet :: [ a ] -> un pachet = seg . 6

Decriptare

După generarea criptării, luați în considerare generarea decriptării, unde fiecare subsecțiune de decriptare este o funcție a uneia dintre subsecțiunile de criptare. Relația dintre cheile de criptare și de decriptare este definită în funcția generateDecSubKeys. Această funcție este realizată prin maparea funcției la o listă de index pregătită. Funcția execute folosește addInv și mulInv, care corespund inversului aditiv și, respectiv, multiplicativ. Această funcție folosește, de asemenea, funcții de ordin superior care preiau o listă de funcții și o listă de valori și aplică (folosind funcția de aplicare) fiecare funcție din prima listă la valoarea corespunzătoare din a doua listă (folosind funcția de ordine superioară zipWith) :

generateDecSubKeys :: [ SubKey ] -> [ SubKey ] generateDecSubKeys eKeys = take 52 ( foldr1 ( ++ ) ( map perform indexes )) unde indicii = mapWith fs ( map reverse ( pachet ( invers [ l | l <- [ 0.. ). 51 ]]))) f1 ( xs ) = shift 2 xs f2 ( xs ) = zipWith ( + ) ( copie ( 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 ( !! ) ( copy eKeys ) ) as ) copy :: a -> Int -> [ a ] copy x n = [ x | i <- [ 1. . n ]] mapWith :: [( a -> b )] -> [ a ] -> [ b ] mapWith fs = zipWith ( apply ) fs apply :: ( a -> b ) -> a -> b apply f = f

Definim o operație aritmetică inversă aditivă (modulo ) și o operație aritmetică inversă multiplicativă (modulo ) Aceste operații sunt funcțiile addInv și mulInv. Funcția addInv introduce pur și simplu un număr pentru a scădea din valoarea modulo: $2^{16}$ $2^{{16}}+1$

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

Pentru a calcula operația aritmetică inversă multiplicativă se folosește algoritmul euclidian extins [9] . Specificația funcțională arată astfel:

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

Analiza și evaluarea performanței

Rezultatele pentru diferitele constructe de criptare (decriptare) reflectă schimbarea performanței. Primul test este cel mai rapid cu un debit maxim de 21,33 Gbps (debit mediu 21,5 Mbps) observat la testarea vectorilor de intrare aleatoriu cu cheia = {1, 2, 3, 4, 5, 6, 7 , opt} . Al doilea test, care corespunde execuției secvențiale a rundelor, are cel mai lent debit așteptat (debit maxim 5,82 Gbps și debit mediu 19,53 Mbps). Este de remarcat faptul că diferitele implementări ale operațiilor aritmetice modulare afectează semnificativ performanța IDEA.

Comparație cu alte implementări

Implementarea folosind Xilinx FPGA (Davor Runje și Mario Kovač) este mult inferioară în performanță, acest lucru se datorează și utilizării sursei de alimentare separate în sloturile PCI (liniile de alimentare I/O și logica principală a plăcilor de expansiune sunt separate de pentru a preveni deteriorarea controlerului).

KH Tsoi, PHW Leong au prezentat o implementare mai performantă bazată pe FPGA Xilinx Virtex XCV300-6. Dar, din nou, debitul nu a fost la cel mai înalt nivel și a rămas în urma implementării lui Ali E. Abdallah și Issam W. Damaj cu un ordin de mărime MHz, în timp ce implementarea serial pe biți oferă 600 Mbps la 150 MHz. Performanța calculată a implementărilor de biți paralel și seriale pe dispozitivul XCV1000-6 este de 5,25 Gb/s, respectiv 2,40 Gb/s [10] .

Allen Michalski, Kris Gaj și Tarek El-Ghazawi au obținut rezultate de 2,5 MB/s - debit de procesare Crypto++. Viteza de procesare hardware a platformei SRC este de 18,5 ori mai mare pentru matrice de date unice și de aproximativ 24 de ori mai rapidă pentru un flux continuu de matrice.

Note

↑ Anthony J. Farrell. Prado, Martial. Gramatică practică spaniolă: un ghid de auto-predare. New York: John Wiley & Sons, 1983; Prado, Martial. Gramatică spaniolă mai practică: un ghid de auto-predare. New York: John Wiley & Sons, 1984 Prado, Marcial. Gramatică practică spaniolă: un ghid de auto-predare. New York: John Wiley & Sons, 1983. pp. viii, 360; Prado, Martial. Gramatică spaniolă mai practică: un ghid de auto-predare. New York: John Wiley & Sons, 1984. pp. vi, 378. Canadian Modern Language Review. — 1985-01. - T. 41 , nr. 3 . — S. 587–588 . - ISSN 1710-1131 0008-4506, 1710-1131 . - doi : 10.3138/cmlr.41.3.587 .
↑ A. Tanenbaum. retele de calculatoare. Prentice Hall, Upper Saddle River, NJ, ediția a treia, 1997
↑ J. Daemen, R. Govaerts și J. Vandewalle. Chei slabe pentru IDEA. Springer-Verlag, paginile 224-231, 1994
↑ D. Runje și M. Kovac. Implementarea centrală FPGA cu criptare puternică universală. În Proceedings of Design, Aautomatizare și Test în Europa, paginile 923-924, 1998
↑ Compensații în implementările paralele și în serie ale algoritmului internațional de criptare a datelor IDEA . (nedefinit)
↑ OYH Cheung, KH Tsoi, PHW Leong și MP Leong. Compensații în implementări în paralel și în serie ale algoritmului internațional de criptare a datelor IDEA. Note de curs în informatică, 2162:333, 2001
↑ Allen Michalski, Kris Gaj și Tarek El-Ghazawi. O comparație de implementare a unui criptosistem de criptare IDEA pe două computere reconfigurabile de uz general. In Field-Programmable Logic and Applications: 13th International Conference, FPL, Lecture Notes in Computer Science, paginile 204-219, Lisabona - Portugalia, 2003. Springer
↑ Sinteza hardware reconfigurabilă a algoritmului criptografic IDEA Ali E. ABDALLAH și Issam W. DAMAJ Institutul de Cercetare pentru Calcul, Regatul Unit
↑ Jean-Luc Beuchat. Multiplicare modulară pentru implementarea FPGA a cifrului bloc IDEA. În Ed Deprettere, Shuvra Bhattacharyya, Joseph Cavallaro, Alain Darte și Lothar Thiele, editori, Proceedings of the 14th IEEE International Conference on Application-Specific Systems, Architectures, and Processors, paginile 412-422. IEEE Computer Society, 2003
↑ Comerțuri în implementări paralele și în serie ale algoritmului internațional de criptare a datelor IDEA . (nedefinit)