CAD Projektowanie układów kryptograficznych rawski@tele.pw.edu.pl http://rawski.zpt.tele.pw.edu.pl/
Kryptografia Kryptografia to dziedzina nauki, zajmująca się przekształcaniem informacji zwanej tekstem jawnym (plaintext) w informację zaszyfrowaną zwaną szyfrogramem (ciphertext) przy wykorzystaniu klucza szyfrującego zdefiniowanego przez użytkownika. Przekształcenie musi być dokonane w taki sposób, aby osoba dysponująca szyfrogramem nie mogła, bez znajomości klucza szyfrującego, odtworzyć tekstu jawnego w rozsądnym czasie. Algorytmy, które dokonują takiego przekształcenia nazywane są szyframi lub algorytmami kryptograficznymi. Większość algorytmów kryptograficznych wykorzystywanych dzisiaj to algorytmy blokowe, które charakteryzują się tym, że jednorazowo przekształcają fragment (blok) tekstu jawnego. Dla porównania algorytmy strumieniowe przekształcają dane o różnej długości. Szyfry strumieniowe mogą być postrzegane jako generatory pseudolosowe z ziarnem (seed), który stanowi klucz szyfrujący. Pseudolosowe liczby generowane przez taki generator są poddawane operacji XOR (sumy modulo 2) z teksem jawnym tworząc szyfrogram Algorytmy kryptograficzne charakteryzują się zazwyczaj dużą złożonością obliczeniową. Z tego powodu najbardziej efektywne realizacje takich algorytmów to realizacje sprzętowe. Algorytmy blokowe najczęściej są bardziej złożone od algorytmów strumieniowych zarówno pod względem zasady działania, jak i realizacji. 2
DES Doskonałym przykładem szyfru blokowego, który ilustruje najbardziej istotne koncepcje wykorzystywane w takich algorytmach jest algorytm DES (Data Encryption Standard). Algorytm DES został zaprojektowany w latach 1970. przez firmę IBM. W 1976 roku organizacja NIST (National Institute of Standards and Technology) zaaprobowała ten algorytm jako oficjalny standard szyfrowania. Został on zaprojektowany pod kontem realizacji sprzętowych, dlatego też realizowany programowo jest bardzo niewydajny. Wraz z upływem czasu algorytm ten stawał się coraz mniej odporny na kryptoanalizę różnicową co spowodowane było nieustannie zwiększającą się możliwością obliczeniową komputerów. W 1997 roku organizacja RSA Security ogłosiła konkurs na złamanie szyfru DES. Konkurs ten wygrał projekt DESCHALL wykorzystując tysiące komputerów połączonych siecią Internet. Czas potrzebny do złamania algorytmu wynosił kilka miesięcy. Rok później organizacja Electronic Frontier Foundation zaprezentowała urządzenie o nazwie Deep Crack. Dzięki wykorzystaniu 1800 układów specjalnie zaprojektowanych w technologii full custom urządzenie to pozwalało złamać algorytm DES w mniej niż 3 dni. Inne rozwiązanie o nazwie COPACOBANA zaproponowane przez zespoły z uniwersytetów Bochum i Kiel zbudowane zostało z wykorzystaniem 120 układów FPGA Spartan3-1000 firmy Xilinx. Średni czas złamania szyfru DES z wykorzystaniem tego urządzenia wynosi ok. 6 dni. W 2001, po zakończeniu międzynarodowego konkursu, organizacja NIST zastąpiła szyfr DES nowym algorytmem AES (Advanced Encryption Standard). 3
Algorytm DES (1) DES (Data Encryption Standard) - jest szyfrem blokowym, o algorytmie ogólnie znanym. Dane są szyfrowane blokami o długości 64 bitów (odpowiada to 8 literom ASCII, każda zaopatrzona w bit parzystości). Blok 64 bitów tekstu jawnego podawany jest jako dane wejściowe algorytmu, wynikiem działania algorytmu jest blok 64 bitów szyfrogramu. Zarówno podczas szyfrowania, jak i deszyfrowania wykorzystuje się ten sam algorytm (za wyjątkiem różnic w operowaniu kluczem). Klucz ma długość 56 bitów. Zwykle klucz jest liczbą zapisaną za pomocą 64 bitów, przy czym każdy co ósmy bit jest bitem parzystości, który jest pomijany (tak jest, gdy klucz jest ciągiem ośmiu znaków alfabetu ASCII). Kluczem może być dowolna liczba o długości 56 bitów, która może być zmieniona w dowolnej chwili. 4
Algorytm DES (2) Działanie algorytmu opiera się na kombinacji dwóch podstawowych technik szyfrowania: mieszania i rozpraszania. Podstawowy blok, z którego jest zbudowany DES stanowi pojedynczą kombinację tych technik (podstawienie, za którym następuje permutacja) działającą z udziałem klucza. Ciąg tych działań nazywany jest rundą. Szyfrowanie i deszyfrowanie za wykorzystaniem algorytmu DES składa się z 16 rund. W trakcie każdej rundy dokonywane są te same obliczenia na wynikach z poprzedniej rundy i specjalnym podkluczu K i generowanym z 64-bitowego klucza. Dodatkowo przed pierwszą i po ostatniej rundzie bity są permutowane w ustalony sposób. Algorytm wykorzystuje tylko standardową arytmetykę i operacje logiczne na liczbach o długości co najwyżej 64 bitów. 5
Algorytm DES (3) Po permutacji początkowej IP blok wejściowy (64- bitowy blok tekstu jawnego) jest dzielony na lewą i prawą połowę, o długości 32 bitów każda. plain_data init_perm key pc1_perm L 0 R 0 C 0 D 0 Następnie wykonywanych jest 16 rund jednakowych operacji, nazywanych funkcjami f, w czasie których dane są łączone z kluczem. f K 1 pc2_perm shl shl Po szesnastym cyklu lewa i prawa połowa są łączone i końcowa permutacja IP-1 będąca odwrotnością permutacji początkowej kończy przebieg algorytmu. L 1 R 1 f K 2 pc2_perm C 1 D 2 shl shl Dla każdej rundy generowany jest oddzielny podklucz K i. Z 64 bitowego klucza głównego K (key) w wyniku permutacji selekcjonującej pc1_perm tworzone są 28 bitowe bloki C i D. Bloki te są przesuwane w lewo o 1 lub 2 bity w zależności od numeru rundy, a następnie przy wykorzystaniu permutacji selekcjonującej pc2_perm jest wybieranych 48 bitów z 56 bitów klucza. L 2 R 2 C 2 D 2 shl shl f K n pc2_perm L 15 R 15 C 15 D 15 shl shl f K 16 pc2_perm L 16 R 16 C 16 D 16 inv_perm ciphered_data 6
Algorytm DES (4) 7
Algorytm DES (5) W każdym cyklu bity klucza są przesuwane, a następnie jest wybieranych 48 bitów z 56 bitów klucza. Prawa połowa bloku danych jest rozszerzana do 48 bitów za pomocą permutacji z rozszerzeniem, łączona za pomocą bitowej sumy modulo 2 z 48 bitami przesuniętego i poddanego permutacji klucza. Następnie jest dokonywane podstawienie bloku 32 nowych bitów za pomocą algorytmu podstawiania, a potem jeszcze raz jest dokonywana permutacja. Te cztery operacje tworzą funkcję f. Ciąg wyjściowy funkcji f jest dalej łączony z lewą połową za pomocą bitowej sumy modulo 2. Wynikiem tych operacji jest nowa prawa połowa bloku; stara prawa połowa staje się nową lewą połową. Operacje te są powtarzane 16 razy, tworząc 16 rund algorytmu DES. 8
Runda algorytmu DES Funkcja opisująca rundę algorytmu DES jest następująca: R i+1 = L i P(S(E(R) i K), i L i+1 = R i, gdzie R, i L i dane wejściowe rundy, R i+1, L i+1 dane wyjściowe rundy, K i podklucz 9
Realizacja programowa Algorytm DES został zaprojektowany z myślą o realizacji sprzętowej. Realizacje programowe tego algorytmy są często mniej wydajne niż inne algorytmy. Przekształcenia wykonywane w procesie szyfrowania nie są operacjami typowymi dla procesorów, czy to ogólnego przeznaczenia (general purpose processors) czy to procesorów sygnałowych (signal processors). Algorytm opiera swe działanie na takich operacjach jak permutacja czy postawienie, które są operacjami manipulacji na bitach. Efektywna realizacja programowa tego typu przekształceń nie jest prosta. 10
Permutacja realizacja programowa W celu zamiany bitów między dwoma słowami danych można wykorzystać makro realizujące tą operację języku C z wykorzystaniem takich operacji bitowych jak przesunięcie, iloczyny i XOR #define DO_PERMUTATION(a, temp, b, offset, mask) \ temp = ((a>>offset) ^ b) & mask; \ b ^= temp; \ a ^= temp<<offset; Zrealizowanie operacji permutacji wymaga wykonania wielu takich zmian bitów. Można wykorzystać pewne prawidłowości występujące w permutacji do uproszczenia całej realizacji. #define INITIAL_PERMUTATION(left, temp, right) \ DO_PERMUTATION(left, temp, right, 4, 0x0f0f0f0f) \ DO_PERMUTATION(left, temp, right,16, 0x0000ffff) \ DO_PERMUTATION(right, temp, left, 2, 0x33333333) \ DO_PERMUTATION(right, temp, left, 8, 0x00ff00ff) \ right = (right << 1) (right >> 31); \ temp = (left ^ right) & 0xaaaaaaaa; \ right ^= temp; \ left ^= temp; \ left = (left << 1) (left >> 31); 11
Wyniki Programowa realizacja w C skompilowana kompilatorem gcc i uruchomiona na komputerze stacjonarnym wyposażonym w procesor Intel Core2 Quad Q9550 taktowany zegarem 3,4 GHz P MultiBlock P SingleBlock [Mbit/s] [Mbit/s] PC 183,91 75,03 Tryb MultiBlock jednen klucza do szyfrowania wszystkich bloków tekstu jawnego (obliczanie podkluczy następuje tylko raz) Tryb SingleBlock każdy blok tekstu jawnego szyfrowany innym kluczem. 12
Permutacja początkowa Permutacja początkowa init_perm dokonuje przestawienia bitów 64 bitowych danych wejściowych według podanej tabeli. plain_data key 58 50 42 34 26 18 10 2 L0 init_perm R0 C0 pc1_perm D0 60 52 44 36 28 20 12 4 f K1 pc2_perm shl shl 62 54 46 38 30 22 14 6 L1 R1 C1 D2 shl shl 64 56 48 40 32 24 16 8 f K2 pc2_perm 57 49 41 33 25 17 9 1 L2 R2 C2 shl D2 shl 59 51 43 35 27 19 11 3 f Kn pc2_permperm L15 R15 C15 D15 61 53 45 37 29 21 13 5 f K16 pc2_perm shl shl 63 55 47 39 31 23 15 7 L16 R16 C16 D16 inv_perm ciphered_data Tablica ta opisuje sposób przestawienia kolejnych bitów danych wejściowych. Jeśli bity danych wejściowych oznaczymy indeksami od 1 do 64 to w wektorze wyjściowym na pozycji pierwszej umieszczamy 58 bit danych wejściowych, na drugiej bit 50, a na ostatniej bit 7. Odczytanie tabeli wierszami utworzy 64 bitowy ciąg będący wynikiem transpozycji. 13
library ieee; use ieee.std_logic_1164.all; Permutacja początkowa VHDL entity init_perm is port( in_data : in std_logic_vector(1 to 64); out_data : out std_logic_vector(1 to 64) ); end; architecture behav of init_perm is begin perm_loop: for i in 0 to 7 generate out_data(i+1) <= in_data(58-8*i); out_data(i+1+8) <= in_data(60-8*i); out_data(i+1+16) <= in_data(62-8*i); out_data(i+1+24) <= in_data(64-8*i); out_data(i+1+32) <= in_data(57-8*i); out_data(i+1+40) <= in_data(59-8*i); out_data(i+1+48) <= in_data(61-8*i); out_data(i+1+56) <= in_data(63-8*i); end generate; end behav; Wykorzystanie struktur języka VHDL do warunkowej generacji kodu ułatwia opis modułu 58 50 42 34 26 18 10 2 60 52 44 36 28 20 12 4 62 54 46 38 30 22 14 6 64 56 48 40 32 24 16 8 57 49 41 33 25 17 9 1 59 51 43 35 27 19 11 3 61 53 45 37 29 21 13 5 63 55 47 39 31 23 15 7 14
Permutacja początkowa wyniki W układzie permutacja została zrealizowana bez wykorzystania komórek Fitter Summary Top-level Entity Name init_perm Family Stratix Device EP1S10F484C5 Total logic elements 0 / 10,570 ( 0 % ) Total pins 128 / 336 ( 38 % ) Total virtual pins 0 Total memory bits 0 / 920,448 ( 0 % ) DSP block 9-bit elements 0 / 48 ( 0 % ) Total PLLs 0 / 6 ( 0 % ) Total DLLs 0 / 2 ( 0 % ) Permutacja to nic innego, jak odpowiednie przestawianie połączeń między wejściem a wyjściem 15
Permutacja końcowa Na wejście tego bloku podane są dane otrzymane po zakończeniu 16 rundy kodowania. 40 8 48 16 56 24 64 32 plain_data init_perm key pc1_perm 39 7 47 15 55 23 63 31 L0 R0 f K1 pc2_perm C0 shl D0 shl 38 6 46 14 54 22 62 30 L1 R1 C1 D2 37 5 45 13 53 21 61 29 f K2 pc2_perm shl shl 36 4 44 12 52 20 60 28 L2 R2 C2 D2 35 3 43 11 51 19 59 27 f Kn pc2_permperm shl shl 34 2 42 10 50 18 58 26 L15 R15 C15 shl D15 shl 33 1 41 9 49 17 57 25 f K16 pc2_perm L16 R16 C16 D16 inv_perm ciphered_data Część danych L i R zostają zamienione miejscami. Otrzymany w ten sposób blok danych 64 bitowych stanowi zaszyfrowany ciąg danych wejściowych. 16
library ieee; use ieee.std_logic_1164.all; Permutacja końcowa VHDL entity inv_perm is port( in_data : in std_logic_vector(1 to 64); out_data : out std_logic_vector(1 to 64) ); end; architecture behav of inv_perm is begin perm_loop: for i in 0 to 7 generate out_data(8*i+1) <= in_data(40-i); out_data(8*i+2) <= in_data( 8-i); out_data(8*i+3) <= in_data(48-i); out_data(8*i+4) <= in_data(16-i); out_data(8*i+5) <= in_data(56-i); out_data(8*i+6) <= in_data(24-i); out_data(8*i+7) <= in_data(64-i); out_data(8*i+8) <= in_data(32-i); end generate; end behav; Wykorzystanie struktur języka VHDL do warunkowej generacji kodu ułatwia opis modułu 40 8 48 16 56 24 64 32 39 7 47 15 55 23 63 31 38 6 46 14 54 22 62 30 37 5 45 13 53 21 61 29 36 4 44 12 52 20 60 28 35 3 43 11 51 19 59 27 34 2 42 10 50 18 58 26 33 1 41 9 49 17 57 25 17
Permutacja końcowa wyniki Fitter Summary Top-level Entity Name inv_perm Family Stratix Device EP1S10F484C5 Total logic elements 0 / 10,570 ( 0 % ) Total pins 128 / 336 ( 38 % ) Total virtual pins 0 Total memory bits 0 / 920,448 ( 0 % ) DSP block 9-bit elements 0 / 48 ( 0 % ) Total PLLs 0 / 6 ( 0 % ) Total DLLs 0 / 2 ( 0 % ) Dokładnie taka sama sytuacja, jak w przypadku permutacji początkowej 18
Permutacja rozszerzająca Permutacja rozszerzająca dokonuje przestawienia bitów w 32 bitowym bloku danych wejściowych z jednoczesnym powieleniem niektórych bitów wejściowych tak, aby uzyskać 48 bitowe dane wyjściowe. Jest to konieczne, aby można było wykonać operację xor z 48 bitowym podkluczem. 32 1 2 3 4 5 4 5 6 7 8 9 8 9 10 11 12 13 12 13 14 15 16 17 16 17 18 19 20 21 20 21 22 23 24 25 24 25 26 27 28 29 28 29 30 31 32 1 19
library ieee; use ieee.std_logic_1164.all; Permutacja rozszerzająca VHDL entity ext_perm is port( in_data : in std_logic_vector(1 to 32); out_data : out std_logic_vector(1 to 48) ); end; architecture behav of ext_perm is begin out_data <= in_data(32) & in_data(1 to 5) & in_data(4 to 9) & in_data(8 to 13) & in_data(12 to 17) & in_data(16 to 21) & in_data(20 to 25) & in_data(24 to 29) & in_data(28 to 32) & in_data(1); end behav; W tym przypadku nie można znaleźć żadnej prawidłowości, więc permutacja jest zapisana kolejne podstawienie bitów 32 1 2 3 4 5 4 5 6 7 8 9 8 9 10 11 12 13 12 13 14 15 16 17 16 17 18 19 20 21 20 21 22 23 24 25 24 25 26 27 28 29 28 29 30 31 32 1 20
Permutacja końcowa wyniki Fitter Summary Top-level Entity Name ext_perm Family Stratix Device EP1S10F484C5 Total logic elements 0 / 10,570 ( 0 % ) Total pins 80 / 336 ( 24 % ) Total virtual pins 0 Total memory bits 0 / 920,448 ( 0 % ) DSP block 9-bit elements 0 / 48 ( 0 % ) Total PLLs 0 / 6 ( 0 % ) Total DLLs 0 / 2 ( 0 % ) Dokładnie taka sama sytuacja, jak w przypadku permutacji początkowej 21
Skrzynki podstawieniowe Każdy blok S-box reprezentuje funkcję dokonującą przekodowania 6 bitowego wektora wejściowego na wektor 4 bitowy. Przekodowanie dokonywane jest zgodnie z zasada przedstawioną w postaci tablicy. S1 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7 0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13 Przy użyciu 8 bloków selekcyjnych wektor 48 bitowy otrzymany przez zastosowanie permutacji rozszerzającej do 32 bitowego wektora wejściowego R rundy przekształcany jest na powrót w wektor 32 bitowy. 22
Skrzynki podstawieniowe VHDL library ieee; use ieee.std_logic_1164.all; entity s1 is port( in_data : in std_logic_vector(1 to 6); out_data : out std_logic_vector(1 to 4) ); end; architecture behav of s1 is signal internl_in : std_logic_vector(1 to 6); begin internl_in <= (in_data(1) & in_data(6) & in_data(2) & in_data(3) & in_data(4) & in_data(5)); with internl_in select out_data <= "1110" when "000000", "0100" when "000001", "1101" when "000010",... "1000" when "000111",... "0110" when "111110", "1101" when "111111", "----" when others; end behav; 00 Bit 1 i 6 określają wiersz pozostałe kolumny S1 000 0111 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7 0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13 23
Skrzynki podstawieniowe wyniki Jeden S-box zajmuje aż tyle komórek wprowadza też duże opóźnienie. Fitter Summary Top-level Entity Name Family Device s1 Stratix EP1S10F484C5 Total logic elements 24 / 10,570 ( < 1 % ) Total pins 10 / 336 ( 3 % ) Total virtual pins 0 Total memory bits 0 / 920,448 ( 0 % ) DSP block 9-bit elements 0 / 48 ( 0 % ) Total PLLs 0 / 6 ( 0 % ) Total DLLs 0 / 2 ( 0 % ) S 1 S 2 S 3 S 4 S 5 S 6 S 7 S 8 Liczba komórek 24 22 24 24 24 23 23 24 Max. opóźnienie 13,5 13,1 13,0 14,0 12,9 13,1 13,0 13,3 24
Permutacji P Dokonuje permutacji na kolejno zestawionych wyjściach z S-boksów wg następującego schematu 16 7 20 21 29 12 28 17 1 15 23 26 5 18 31 10 2 8 24 14 32 27 3 9 19 13 30 6 22 11 4 25 Wynik permutacji P jest sumowany bitowo modulo 2 z częścią L początkowego bloku 64-bitowego i tak stworzony blok 32-bitowy podawany jest jako część R dla rundy następnej. 25
Permutacji P VHDL library ieee; use ieee.std_logic_1164.all; entity p_perm is port( in_data : in std_logic_vector(1 to 32); out_data : out std_logic_vector(1 to 32) ); end; architecture behav of p_perm is begin out_data <= in_data(16) & in_data(7) & in_data(20) & in_data(21) & in_data(29) & in_data(12) & in_data(28) & in_data(17) & in_data(1) & in_data(15) & in_data(23) & in_data(26) & in_data(5) & in_data(18) & in_data(31) & in_data(10) & in_data(2) & in_data(8) & in_data(24) & in_data(14) & in_data(32) & in_data(27) & in_data(3) & in_data(9) & in_data(19) & in_data(13) & in_data(30) & in_data(6) & in_data(22) & in_data(11) & in_data(4) & in_data(25); end behav; W tym przypadku nie można znaleźć żadnej prawidłowości, więc permutacja jest zapisana kolejne podstawienie bitów 16 7 20 21 29 12 28 17 1 15 23 26 5 18 31 10 2 8 24 14 32 27 3 9 19 13 30 6 22 11 4 25 26
Permutacji PC-1 Blok ten dokonuje permutacji 64 bitowego bloku klucza. W wyniku otrzymuje się 56 bitowy blok, który dzielony jest na 28 bitowe bliki C i D plain_data key init_perm pc1_perm L0 R0 C0 D0 shl shl 57 49 41 33 25 17 9 1 58 50 42 34 26 18 10 2 59 51 43 35 27 19 11 3 60 52 44 36 63 55 47 39 31 23 15 7 62 54 46 38 30 22 14 6 61 53 45 37 29 21 13 5 28 20 12 4 f K1 pc2_perm L1 R1 C1 D2 shl shl f K2 pc2_perm L2 R2 C2 D2 shl shl f Kn pc2_perm L15 R15 C15 D15 shl shl f K16 pc2_perm L16 R16 C16 D16 inv_perm ciphered_data 27
library ieee; use ieee.std_logic_1164.all; Permutacji PC-1 VHDL entity pc1_perm is port( in_data : in std_logic_vector(1 to 64); out_data : out std_logic_vector(1 to 56) ); end; architecture behav of pc1_perm is begin out_data <= in_data(57) & in_data(49) & in_data(41) & in_data(33) & in_data(25) & in_data(17) & in_data(9) & in_data(1) & in_data(58) & in_data(50) & in_data(42) & in_data(34) & in_data(26) & in_data(18) & in_data(10) & in_data(2) & in_data(59) & in_data(51) & in_data(43) & in_data(35) & in_data(27) & in_data(19) & in_data(11) & in_data(3) & in_data(60) & in_data(52) & in_data(44) & in_data(36) & in_data(63) & in_data(55) & in_data(47) & in_data(39) & in_data(31) & in_data(23) & in_data(15) & in_data(7) & in_data(62) & in_data(54) & in_data(46) & in_data(38) & in_data(30) & in_data(22) & in_data(14) & in_data(6) & in_data(61) & in_data(53) & in_data(45) & in_data(37) & in_data(29) & in_data(21) & in_data(13) & in_data(5) & in_data(28) & in_data(20) & in_data(12) & in_data(4); end behav; 28
Permutacji PC-2 Blok ten dokonuje permutacji 58 bitowego bloku powstałego w wyniku przesunięcia w lewo blików C i D. W wyniku otrzymuje się 48 blok, który stanowi podklucz dla danej rundy. plain_data key init_perm pc1_perm 14 17 11 24 1 5 3 28 15 6 21 10 23 19 12 4 26 8 16 7 27 20 13 2 41 52 31 37 47 55 30 40 51 45 33 48 44 49 39 56 34 53 46 42 50 36 29 32 L0 R0 C0 D0 shl shl f K1 pc2_perm L1 R1 C1 D2 shl shl f K2 pc2_perm L2 R2 C2 D2 shl shl f Kn pc2_perm L15 R15 C15 D15 shl shl f K16 pc2_perm L16 R16 C16 D16 inv_perm ciphered_data 29
library ieee; use ieee.std_logic_1164.all; Permutacji PC-2 VHDL entity pc2_perm is port( in_data : in std_logic_vector(1 to 56); out_data : out std_logic_vector(1 to 48) ); end; architecture behav of pc2_perm is begin out_data <= in_data(14) & in_data(17) & in_data(11) & in_data(24) & in_data(1) & in_data(5) & in_data(3) & in_data(28) & in_data(15) & in_data(6) & in_data(21) & in_data(10) & in_data(23) & in_data(19) & in_data(12) & in_data(4) & in_data(26) & in_data(8) & in_data(16) & in_data(7) & in_data(27) & in_data(20) & in_data(13) & in_data(2) & in_data(41) & in_data(52) & in_data(31) & in_data(37) & in_data(47) & in_data(55) & in_data(30) & in_data(40) & in_data(51) & in_data(45) & in_data(33) & in_data(48) & in_data(44) & in_data(49) & in_data(39) & in_data(56) & in_data(34) & in_data(53) & in_data(46) & in_data(42) & in_data(50) & in_data(36) & in_data(29) & in_data(32); end behav; 30
Runda algorytmu DES Jest to podstawowy element algorytmu DES. Jakość realizacji tego bloku będzie decydować o szybkości działania całego algorytmu i wielkości zasobów niezbędnych do realizacji algorytmu w sprzęcie. Blok ten składa się z permutacji rozszerzającej ext_perm, ośmiu skrzynek selekcyjnych S-Box, permutacji p_perm, permutacji pc2_perm i bloków shl realizujących przesunięcie w lewo o 1 lub 2 bity. Nazwa Typ Rozmiar Opis l_i in 32 część danych poddawanych przekształceniu w danej rundzie r_i in 32 część danych poddawanych przekształceniu w danej rundzie c_i in 28 część klucza dla danej rundy d_i in 28 część klucza dla danej rundy shift_i in 1 przesunięcie przy generacji podklucza : 0 przesunięcie o 1 bit w lewo 1 przesunięcie o 2 bit w lewo l_o out 32 część danych przekształconych w danej rundzie r_o out 32 część danych przekształconych w danej rundzie c_o out 28 część klucza dla następnej rundy d_o out 28 część klucza dla następnej rundy 31
library ieee; use ieee.std_logic_1164.all; use work.des_design.all; Runda algorytmu DES VHDL (1) entity data_rund is port( shift_i : in std_logic; r_i, l_i : in std_logic_vector(1 to 32); c_i, d_i : in std_logic_vector(1 to 28); r_o, l_o : out std_logic_vector(1 to 32); c_o, d_o : out std_logic_vector(1 to 28) ); end; architecture structure of data_rund is signal extended_data : std_logic_vector(1 to 48); signal key_xored_data : std_logic_vector(1 to 48); signal sbox_out_data : std_logic_vector(1 to 32); signal permuted_data : std_logic_vector(1 to 32); signal c_shifted : std_logic_vector(1 to 28); signal d_shifted : std_logic_vector(1 to 28); signal sub_key : std_logic_vector(1 to 48); Lokalne sygnały do połączenia bloków 32
Runda algorytmu DES VHDL (2) begin with shift_i select c_shifted <= c_i(2 to 28) & c_i(1) when '0', c_i(3 to 28) & c_i(1 to 2) when others; with shift_i select d_shifted <= d_i(2 to 28) & d_i(1) when '0', d_i(3 to 28) & d_i(1 to 2) when others; b0 : pc2_perm port map( in_data => (c_shifted & d_shifted), out_data => sub_key ); Moduły przesuwające Permutacja PC-2 c_o <= c_shifted; d_o <= d_shifted; b1 : ext_perm port map( in_data => r_i, out_data => extended_data ); key_xored_data <= extended_data xor sub_key; Permutacja rozszerzająca Połączenie z kluczem 33
Runda algorytmu DES VHDL (2) b2 : s1 port map( in_data => key_xored_data(1 to 6), out_data => sbox_out_data(1 to 4) ); b3 : s2 port map( in_data => key_xored_data(7 to 12), out_data => sbox_out_data(5 to 8) ); Skrzynki podstawieniowe S-Box b9 : s8 port map( in_data => key_xored_data(43 to 48), out_data => sbox_out_data(29 to 32) ); b10: p_perm port map( in_data => sbox_out_data, out_data => permuted_data ); r_o <= permuted_data xor l_i; l_o <= r_i; end structure; Permutacja P XOR z lewą częścia danych 34
Runda algorytmu DES wyniki Fitter Summary Top-level Entity Name des_rund Family Stratix Device EP1S10F484C5 Total logic elements 298 / 10,570 ( 3 % ) Total pins 241 / 336 ( 72 % ) Total virtual pins 0 Total memory bits 0 / 920,448 ( 0 % ) DSP block 9-bit elements 0 / 48 ( 0 % ) Total PLLs 0 / 6 ( 0 % ) Total DLLs 0 / 2 ( 0 % ) Maksymalne opóźnienie 16,4 ns pozwala wykonać ok. 60 mln rund na sekundę! Runda algorytmu DES wymaga 298 komórek logicznych. Algorytm składa się z 16 rund a to oznacza, ze realizacja całości wymaga sporo zasobów logicznych 35
Realizacja iteracyjna algorytmu DES Podstawowym elementem składowym realizacji sprzętowe algorytmu DES jest przekształcenie zwane rundą. Realizacja iteracyjna wykorzystuje fakt, że algorytm ten jest zbudowany z 16 identycznych rund. Dzięki temu możliwe jest zaimplementowanie jednego bloku rundy algorytmu i wykorzystanie odpowiedniego sterowania do sekwencyjnej realizacji tego algorytmu. 36
Koncepcja iteracyjnej realizacji algorytmu DES (1) Głównym elementem jest blok des_rund, który realizuje pojedynczą rundę algorytmu. Rejestry R i L przechowują części danych poddawanych przekształceniom w rundzie algorytmu. Do tych rejestrów mogą być wpisane dane data_perm (dane wejściowe plain_data poddane permutacji początkowej init_perm) albo dane l_out i r_out stanowiące wynik działania rundy. 37
Koncepcja iteracyjnej realizacji algorytmu DES (2) Rejestry C i D przechowują dane niezbędne do generacji podkluczy rundowych. Mogą one zostać załadowane wartością key_perm (klucz key poddany permutacji pc1_perm) lub wartościami c_out i d_out stanowiące wynik przekształcenia klucza w rundzie. Sygnał shift wykorzystywany jest do kontrolowania o ile bitów należy przesunąć połówki klucza w czasie generacji podklucza dla danej rundy (0 przesunięcie o 1 bit, 1 przesunięcie o 2 bity). 38
Koncepcja iteracyjnej realizacji algorytmu DES (3) Wyjścia rundy l_out i r_out podłączone są do permutacji końcowej której wynik data_final zapamiętywany jest w rejestrze result po całym procesie szyfrowania danego bloku. Zawartość tego rejestru podawana jest na wyjście ciphered_data. 39
Schemat blokowy algorytmu iteracyjnego DES (1) W momencie pojawienia się sygnału start do zmiennych C i D ładowane są 28 bitowe bloki wektora key_perm (klucza poddanego permutacji pc1_perm). Następnie do zmiennych L i R ładowane są bloki wektora data_perm (tekst jawny poddanego permutacji początkowej init_perm). W tym samym czasie licznik rund cnt ustawiany jest na 1 zaś zmienna shift na 0 (w rundzie 1 przesuniecie przy generacji podklucza wynosi 1 bit). Następnie w pętli wykonywanych jest 15 pozostałych rund. W każdej iteracji licznik rund zwiększany jest o jeden zmienne R, L, C i D ładowane są wartościami l_out, r_out, c_out i d_out będącymi wynikiem obliczeń wykonywanych w ramach rundy algorytmu. 40
Schemat blokowy algorytmu iteracyjnego DES (2) Wartość shift ustalana jest na 0 dla rund 2, 9 i 16 a w pozostałych przypadkach na 1. W momencie, gdy wykonana zostanie ostatnia ruda (cnt = 16) sygnał ready ustawiany jest na 1, zaś do zmiennej result ładowany jest wynik permutacji końcowej data_final. Jeśli sygnał start ma wartość 1 do zmiennych L i R ładowane są nowe bloki wektora data_perm i szyfrowanie kontynuowane jest przy użyci tego samego klucza jaki był użyty do szyfrowania poprzedniego bloku. W przeciwnym przypadku sterowanie przekazywane jest na początek algorytmu. Pojawienie się wartości 1 na sygnale start ponownie uruchamia algorytm pozwalając wczytać nowy klucz i nowe dane do szyfrowania. 41
Diagram ASM Do realizacji tego algorytmu można wykorzystać metodologię projektowania opartą na algorytmicznych układach sekwencyjnych ze ścieżką przepływu danych ASMD (Algorithmic State Machine with Data Path). Diagram ten składa się z 4 bloków ASM odpowiadających stanom automatu: idle, read, run, store. W stanie idle układ oczekuje na pojawienie się sygnału start. W stanie read do rejestrów L i R ładowane są dane z wektora data_perm, który przechowuje blok danych tekstu jawnego plain_data poddany permutacji początkowej init_perm. W stanie run wykonywane są kolejne rundy algorytmu. W stanie store wynik ostatniej rundy poddany permutacji inv_perm zapamiętany zostaje w rejestrze result zaś rejestr ready otrzymuje wartość 1. 42
Iteracyjna realizacja algorytmu DES VHDL (1) library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; use work.des_design.all; entity des_seq is port( clk : in std_logic; reset : in std_logic; start : in std_logic; plain_data : in std_logic_vector(1 to 64); key : in std_logic_vector(1 to 64); ready : out std_logic; ciphered_data : out std_logic_vector(1 to 64) ); end; Nazwa Typ Rozmiar Opis clk in 1 zegar systemowy reset in 1 reset systemowy start in 1 sygnał rozpoczęcia szyfrowania plain_data in 64 blok danych do zaszyfrowania key in 64 klucz wykorzystywany do szyfrowania ready out 1 sygnał końca procesu szyfrowania danego bloku ciphered_data out 64 szyfrogram danego bloku danych tekstu jawnego 43
Iteracyjna realizacja algorytmu DES VHDL (2) architecture RTL of des_seq is signal data_perm : std_logic_vector(1 to 64); signal data_final : std_logic_vector(1 to 64); signal r_out : std_logic_vector(1 to 32); signal l_out : std_logic_vector(1 to 32); signal key_perm : std_logic_vector(1 to 56); signal c_out : std_logic_vector(1 to 28); signal d_out : std_logic_vector(1 to 28); signal last_rund_res : std_logic_vector(1 to 64); signal ready_reg, ready_next : std_logic; signal shift_reg, shift_next : std_logic; signal cnt_reg, cnt_next : unsigned(0 to 4); signal C_reg, C_next : std_logic_vector(1 to 28); signal D_reg, D_next : std_logic_vector(1 to 28); signal L_reg, L_next : std_logic_vector(1 to 32); signal R_reg, R_next : std_logic_vector(1 to 32); signal result_reg, result_next : std_logic_vector(1 to 64); type STATE_TYPE is (idle, read, run, store); signal aut_reg, aut_next : STATE_TYPE; 44
Iteracyjna realizacja algorytmu DES VHDL (3) process(clk, reset) begin if reset = '1' then aut_reg <= idle; shift_reg <= '0'; ready_reg <= '0'; L_reg <= (others => '0'); R_reg <= (others => '0'); C_reg <= (others => '0'); D_reg <= (others => '0'); cnt_reg <= (others => '0'); result_reg <= (others => '0'); elsif rising_edge(clk) then aut_reg <= aut_next; ready_reg <= ready_next; L_reg <= L_next; R_reg <= R_next; C_reg <= C_next; D_reg <= D_next; shift_reg <= shift_next; cnt_reg <= cnt_next; result_reg <= result_next; end if; end process; 45
Iteracyjna realizacja algorytmu DES VHDL (4) process(aut_reg, start, cnt_next) begin ready_next <= '0'; case aut_reg is when idle => if start = '1' then aut_next <= read; else aut_next <= idle; end if; when read => aut_next <= run; when run => if cnt_next = 16 then aut_next <= store; else aut_next <= run; end if; when store => ready_next <= '1'; if start = '1' then aut_next <= run; else aut_next <= idle; end if; when others => aut_next <= idle; end case; end process; 46
Iteracyjna realizacja algorytmu DES VHDL (5) process( aut_reg, start,data_perm, key_perm, data_final, cnt_reg, cnt_next, L_reg, R_reg, C_reg, D_reg, shift_reg, result_reg, r_out, l_out, c_out, d_out) begin C_next <= C_reg; D_next <= D_reg; L_next <= L_reg; R_next <= R_reg; shift_next <= shift_reg; cnt_next <= cnt_reg; result_next <= result_reg; case aut_reg is when idle => if start = '1' then C_next <= key_perm(1 to 28); D_next <= key_perm(29 to 56); end if; when read => cnt_next <= to_unsigned(1, 5); L_next <= data_perm(1 to 32); R_next <= data_perm(33 to 64); shift_next <= '0'; 47