Iteracyjna realizacja algorytmu DES – VHDL

Transkrypt

CAD
Projektowanie układów
kryptograficznych
Mariusz Rawski
[email protected]
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.
Mariusz Rawski
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).
Mariusz Rawski
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.
Mariusz Rawski
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 Ki 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.
Mariusz Rawski
5
Algorytm DES (3)
•
Po permutacji początkowej IP blok wejściowy (64bitowy blok tekstu jawnego) jest dzielony na lewą i
prawą połowę, o długości 32 bitów każda.
plain_data
key
init_perm
pc1_perm
L0
•
•
•
R0
Następnie wykonywanych jest 16 rund jednakowych
operacji, nazywanych funkcjami f, w czasie których
dane są łączone z kluczem.
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.
Dla każdej rundy generowany jest oddzielny
podklucz Ki . 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.
f
L1
K1
f
L2
L15
Kn
f
L16
R16
shl
C1
D2
shl
shl
C2
D2
shl
shl
C15
D15
shl
shl
C16
D16
pc2_perm
R15
K16
shl
pc2_perm
R2
f
D0
pc2_perm
R1
K2
C0
pc2_perm
inv_perm
ciphered_data
Mariusz Rawski
6
Algorytm DES (4)
Mariusz Rawski
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.
Mariusz Rawski
8
Runda algorytmu DES
•
Funkcja opisująca rundę algorytmu DES jest następująca:
Ri+1 = Li ⊕ P(S(E(Ri) ⊕ Ki),
Li+1 = Ri,
gdzie Ri, Li – dane wejściowe rundy, Ri+1, Li+1 – dane wyjściowe rundy, Ki – podklucz
Mariusz Rawski
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.
Mariusz Rawski
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);
Mariusz Rawski
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
PC
•
•
PMultiBlock
PSingleBlock
[Mbit/s]
[Mbit/s]
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.
Mariusz Rawski
12
Permutacja początkowa
•
Permutacja początkowa init_perm dokonuje przestawienia bitów 64 bitowych
danych wejściowych według podanej tabeli.
58 50 42 34 26 18 10 2
plain_data
key
init_perm
pc1_perm
L0
R0
60 52 44 36 28 20 12 4
62 54 46 38 30 22 14 6
f
L1
f
L2
K2
R2
Kn
shl
shl
C1
D2
shl
shl
pc2_perm
1
f
D0
pc2_perm
R1
64 56 48 40 32 24 16 8
57 49 41 33 25 17 9
K1
C0
C2
D2
shl
shl
C15
D15
shl
shl
C16
D16
pc2 perm
pc2_perm
59 51 43 35 27 19 11 3
L15
R15
61 53 45 37 29 21 13 5
63 55 47 39 31 23 15 7
f
L16
R16
K16
pc2_perm
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.
Mariusz Rawski
13
Permutacja początkowa – VHDL
library ieee;
use ieee.std_logic_1164.all;
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);
end generate;
end behav;
Mariusz Rawski
Wykorzystanie struktur języka VHDL
do warunkowej generacji kodu ułatwia
opis modułu
58 50 42 34 26 18 10
60 52 44 36 28 20 12
62 54 46 38 30 22 14
64 56 48 40 32 24 16
57 49 41 33 25 17 9
59 51 43 35 27 19 11
61 53 45 37 29 21 13
63 55 47 39 31 23 15
2
4
6
8
1
3
5
7
14
Permutacja początkowa – wyniki
Fitter Summary
W układzie permutacja
została zrealizowana bez
wykorzystania komórek
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
Mariusz Rawski
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
key
init_perm
pc1_perm
L0
39 7
38 6
R0
47 15 55 23 63 31
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
f
L1
f
L2
41 9
K2
L15
Kn
shl
C1
D2
shl
shl
C2
D2
shl
shl
C15
D15
shl
shl
C16
D16
pc2 perm
pc2_perm
R15
K16
shl
pc2_perm
R2
f
D0
pc2_perm
R1
f
33 1
K1
C0
pc2_perm
49 17 57 25
L16
R16
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.
Mariusz Rawski
16
Permutacja końcowa – VHDL
library ieee;
entity inv_perm is
port(
in_data
);
end;
architecture behav of inv_perm is
begin
perm_loop:
out_data(8*i+1) <= in_data(40-i);
out_data(8*i+2) <= in_data( 8-i);
end generate;
end behav;
Mariusz Rawski
Wykorzystanie struktur języka VHDL
do warunkowej generacji kodu ułatwia
opis modułu
40
39
38
37
36
35
34
33
8
7
6
5
4
3
2
1
48
47
46
45
44
43
42
41
16
15
14
13
12
11
10
9
56
55
54
53
52
51
50
49
24
23
22
21
20
19
18
17
64
63
62
61
60
59
58
57
32
31
30
29
28
27
26
25
17
Permutacja końcowa – wyniki
Fitter Summary
inv_perm
Family
Stratix
Device
EP1S10F484C5
0 / 10,570 ( 0 % )
Total pins
128 / 336 ( 38 % )
Total virtual pins
0
Total memory bits
0 / 920,448 ( 0 % )
0 / 48 ( 0 % )
Total PLLs
0/6(0%)
Total DLLs
0/2(0%)
Dokładnie taka sama
sytuacja, jak w przypadku
permutacji początkowej
Mariusz Rawski
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
Mariusz Rawski
19
Permutacja rozszerzająca – VHDL
library ieee;
entity ext_perm is
port(
in_data
);
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(28 to 32) & in_data(1);
end behav;
Mariusz Rawski
W tym przypadku nie można znaleźć
żadnej
prawidłowości,
więc
permutacja jest zapisana kolejne
podstawienie bitów
32
4
8
12
16
20
24
28
1
5
9
13
17
21
25
29
2
6
10
14
18
22
26
30
3
7
11
15
19
23
27
31
4
8
12
16
20
24
28
32
5
9
13
17
21
25
29
1
20
Permutacja końcowa – wyniki
Fitter Summary
ext_perm
Family
Stratix
Device
EP1S10F484C5
0 / 10,570 ( 0 % )
Total pins
80 / 336 ( 24 % )
Total virtual pins
0
Total memory bits
0 / 920,448 ( 0 % )
0 / 48 ( 0 % )
Total PLLs
0/6(0%)
Total DLLs
0/2(0%)
Dokładnie taka sama
sytuacja, jak w przypadku
permutacji początkowej
Mariusz Rawski
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
0 15
4
•
7 4 14 2 13 1 10
1 14 8 13 6
15 12
3 10
8 2
4 9
6
12
5
9 0
7
6 12
11
9
5 3
8
3 10 5
0
2 11 15 12
9
1 7
3
5 11
7
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.
Mariusz Rawski
22
Skrzynki podstawieniowe – VHDL
library ieee;
entity s1 is
port(
in_data
);
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;
Mariusz Rawski
Bit 1 i 6 określają
pozostałe kolumny
000
wiersz
0111
S1
14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7
00
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
Fitter Summary
s1
Family
Stratix
Device
EP1S10F484C5
24 / 10,570 ( < 1 % )
Total pins
10 / 336 ( 3 % )
Total virtual pins
0
Total memory bits
0 / 920,448 ( 0 % )
0 / 48 ( 0 % )
Total PLLs
0/6(0%)
Total DLLs
0/2(0%)
Jeden S-box zajmuje aż
tyle komórek…
wprowadza
też duże opóźnienie.
S1
S2
S3
S4
S5
S6
S7
S8
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
Mariusz Rawski
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.
Mariusz Rawski
25
Permutacji P – VHDL
library ieee;
entity p_perm is
port(
in_data
);
end;
architecture behav of p_perm is
begin
out_data <=
in_data(16) & in_data(7) & in_data(20) & in_data(21) &
in_data(22) & in_data(11) & in_data(4) & in_data(25);
end behav;
Mariusz Rawski
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
f
57 49 41 33 25 17
2 59 51 43 35 27
f
L2
f
L15
f
L16
21 13
Mariusz Rawski
5 28 20 12
shl
4
Kn
R16
K16
C1
D2
shl
shl
pc2_perm
C2
D2
shl
shl
C15
D15
shl
shl
C16
D16
pc2_perm
R15
7 62 54 46 38 30 22
6 61 53 45 37 29
K2
R2
3 60 52 44 36
63 55 47 39 31 23 15
14
shl
pc2_perm
R1
1 58 50 42 34 26 18
19 11
D0
9
L1
10
K1
C0
pc2_perm
inv_perm
ciphered_data
27
Permutacji PC-1 – VHDL
library ieee;
entity pc1_perm is
port(
in_data
: in std_logic_vector(1 to
out_data : out std_logic_vector(1 to
);
end;
architecture behav of pc1_perm is
begin
out_data <= in_data(57) & in_data(49)
in_data(25) & in_data(17)
end behav;
Mariusz Rawski
64);
56)
&
&
&
&
&
&
&
&
&
&
&
&
&
&
in_data(41)
in_data(9)
in_data(42)
in_data(10)
in_data(43)
in_data(11)
in_data(44)
in_data(47)
in_data(15)
in_data(46)
in_data(14)
in_data(45)
in_data(13)
in_data(12)
&
&
&
&
&
&
&
&
&
&
&
&
&
&
in_data(33)
in_data(1)
in_data(34)
in_data(2)
in_data(35)
in_data(3)
in_data(36)
in_data(39)
in_data(7)
in_data(38)
in_data(6)
in_data(37)
in_data(5)
in_data(4);
&
&
&
&
&
&
&
&
&
&
&
&
&
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.
14 17 11 24
1
5
plain_data
key
init_perm
pc1_perm
L0
R0
f
3 28 15
16
D0
shl
C1
D2
shl
shl
C2
D2
shl
shl
C15
D15
shl
shl
C16
D16
pc2_perm
6 21 10
L1
23 19 12
K1
C0
shl
4 26
7 27 20 13
R1
8
2
f
L2
f
L15
Kn
pc2_perm
R15
f
44 49 39 56 34 53
46 42 50 36 29 32
pc2_perm
R2
41 52 31 37 47 55
30 40 51 45 33 48
K2
L16
R16
K16
pc2_perm
inv_perm
ciphered_data
Mariusz Rawski
29
Permutacji PC-2 – VHDL
library ieee;
entity pc2_perm is
port(
in_data
: in std_logic_vector(1 to
out_data : out std_logic_vector(1 to
);
end;
architecture behav of pc2_perm is
begin
out_data <= in_data(14) & in_data(17)
end behav;
Mariusz Rawski
56);
48)
&
&
&
&
&
&
&
&
&
&
&
&
in_data(11)
in_data(3)
in_data(21)
in_data(12)
in_data(16)
in_data(13)
in_data(31)
in_data(30)
in_data(33)
in_data(39)
in_data(46)
in_data(29)
&
&
&
&
&
&
&
&
&
&
&
&
in_data(24) &
in_data(28) &
in_data(10) &
in_data(4) &
in_data(7) &
in_data(2) &
in_data(37) &
in_data(40) &
in_data(48) &
in_data(56) &
in_data(42) &
in_data(32);
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
l_i
r_i
c_i
d_i
shift_i
l_o
r_o
c_o
d_o
Typ
in
in
in
in
in
out
out
out
out
Mariusz Rawski
Rozmiar
32
32
28
28
1
32
32
28
28
Opis
część danych poddawanych przekształceniu w danej rundzie
część danych poddawanych przekształceniu w danej rundzie
część klucza dla danej rundy
część klucza dla danej rundy
przesunięcie przy generacji podklucza : 0 – przesunięcie o 1 bit w lewo 1 – przesunięcie o 2 bit w lewo
część danych przekształconych w danej rundzie
część danych przekształconych w danej rundzie
część klucza dla następnej rundy
część klucza dla następnej rundy
31
Runda algorytmu DES – VHDL (1)
library ieee;
use work.des_design.all;
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
signal key_xored_data
signal sbox_out_data
signal permuted_data
signal c_shifted
signal d_shifted
signal sub_key
Mariusz Rawski
to
to
to
to
48);
48);
32);
32);
Lokalne sygnały do połączenia
bloków
: std_logic_vector(1 to 28);
32
begin
with shift_i select
c_shifted <= c_i(2 to 28) & c_i(1) when
c_i(3 to 28) & c_i(1 to 2) when
'0',
others;
with shift_i select
d_shifted <= d_i(2 to 28) & d_i(1) when
d_i(3 to 28) & d_i(1 to 2) when
'0',
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;
Mariusz Rawski
Permutacja rozszerzająca
Połączenie z kluczem
33
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
);
Skrzynki podstawieniowe S-Box
●●●
b9 : s8 port map(
in_data
);
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;
Mariusz Rawski
Permutacja P
XOR z lewą częścia danych
34
Runda algorytmu DES – wyniki
Fitter Summary
Maksymalne opóźnienie
16,4 ns pozwala wykonać
ok. 60 mln rund na
sekundę!
Mariusz Rawski
des_rund
Family
Stratix
Device
EP1S10F484C5
298 / 10,570 ( 3 % )
Total pins
241 / 336 ( 72 % )
Total virtual pins
0
Total memory bits
0 / 920,448 ( 0 % )
0 / 48 ( 0 % )
Total PLLs
0/6(0%)
Total DLLs
0/2(0%)
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.
Mariusz Rawski
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.
Mariusz Rawski
37
•
•
•
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).
Mariusz Rawski
38
•
•
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.
Mariusz Rawski
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.
Mariusz Rawski
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.
Mariusz Rawski
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.
Mariusz Rawski
42
Iteracyjna realizacja algorytmu DES – VHDL (1)
library ieee;
use ieee.numeric_std.all;
entity des_seq is
port(
clk
reset
start
plain_data
key
ready
ciphered_data
);
end;
Nazwa
clk
reset
start
plain_data
key
ready
ciphered_data
Mariusz Rawski
:
:
:
:
:
:
:
in std_logic;
in std_logic;
in std_logic;
in std_logic_vector(1 to 64);
out std_logic;
out std_logic_vector(1 to 64)
Typ
in
in
in
in
in
out
out
Rozmiar
1
1
1
64
64
1
64
Opis
zegar systemowy
reset systemowy
sygnał rozpoczęcia szyfrowania
blok danych do zaszyfrowania
klucz wykorzystywany do szyfrowania
sygnał końca procesu szyfrowania danego bloku
szyfrogram danego bloku danych tekstu jawnego
43
architecture RTL of des_seq is
signal data_perm
signal data_final
signal r_out
signal l_out
signal key_perm
signal c_out
signal d_out
signal last_rund_res
signal
signal
signal
signal
signal
signal
signal
signal
:
:
:
:
:
:
:
:
ready_reg, ready_next
shift_reg, shift_next
cnt_reg, cnt_next
C_reg, C_next
D_reg, D_next
L_reg, L_next
R_reg, R_next
result_reg, result_next
std_logic_vector(1
std_logic_vector(1
std_logic_vector(1
std_logic_vector(1
std_logic_vector(1
std_logic_vector(1
std_logic_vector(1
std_logic_vector(1
:
:
:
:
:
:
:
:
to
to
to
to
to
to
to
to
std_logic;
std_logic;
unsigned(0 to 4);
std_logic_vector(1
std_logic_vector(1
std_logic_vector(1
std_logic_vector(1
std_logic_vector(1
64);
64);
32);
32);
56);
28);
28);
64);
to
to
to
to
to
28);
28);
32);
32);
64);
type STATE_TYPE is (idle, read, run, store);
signal aut_reg, aut_next
: STATE_TYPE;
Mariusz Rawski
44
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;
Mariusz Rawski
45
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;
Mariusz Rawski
when others =>
aut_next <= idle;
end case;
end process;
46
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'
C_next
<=
D_next
<=
end if;
when read =>
cnt_next
<=
L_next
<=
R_next
<=
shift_next <=
Mariusz Rawski
then
key_perm(1 to 28);
key_perm(29 to 56);
to_unsigned(1, 5);
data_perm(1 to 32);
data_perm(33 to 64);
'0';
47
when run =>
cnt_next
L_next
R_next
C_next
D_next
<=
<=
<=
<=
<=
cnt_reg + 1;
l_out;
r_out;
c_out;
d_out;
if cnt_next = 16 then
shift_next <= '0';
elsif (cnt_next = 2) or (cnt_next = 9) then
shift_next <= '0';
else
shift_next <= '1';
end if;
when store =>
result_next
<= data_final;
if start = '1' then
cnt_next <= to_unsigned(1, 5);
L_next
<= data_perm(1 to 32);
R_next
<= data_perm(33 to 64);
shift_next <= '1';
end if;
end case;
end process;
Mariusz Rawski
48
b1 : init_perm port map(
in_data
=> plain_data,
out_data => data_perm
);
last_rund_res <= r_out &
l_out;
b2 : inv_perm port map(
in_data
=> last_rund_res,
out_data => data_final
);
in_data
=> key,
out_data => key_perm
);
Mariusz Rawski
b4 : des_rund port map(
shift_i => shift_reg,
r_i
=> R_reg,
l_i
=> L_reg,
c_i
=> C_reg,
d_i
=> D_reg,
r_o
=> r_out,
l_o
=> l_out,
c_o
=> c_out,
d_o
=> d_out
);
ready
ciphered_data
end;
<= ready_reg;
<= result_reg;
49
Iteracyjna realizacja algorytmu DES – wyniki
Fitter Summary
des_seq
Family
Stratix
Device
EP1S10F484C5
449 / 10,570 ( 4 % )
Total pins
196 / 336 ( 58 % )
Total virtual pins
0
Total memory bits
0 / 920,448 ( 0 % )
0 / 48 ( 0 % )
Total PLLs
0/6(0%)
Total DLLs
0/2(0%)
Przepustowość dla wersji iteracyjnej :
thruput iter = fMAX × data_size / 16
thruput iter = 604 Mbit/s
wczytanie klucza
wczytanie danych
Mariusz Rawski
szyfrogram gotowy
50
Realizacja kombinacyjna algorytmu DES
•
•
•
•
Realizacja iteracyjna algorytmu DES ma niewątpliwą zaletę – niewielkie
zapotrzebowanie na zasoby.
Implementacja jednego bloku rundy, który jest wykorzystywany sekwencyjnie do
obliczania 16 rund algorytmu DES, ma jednakże też wadę. Do zaszyfrowania
jednego bloku danych wymaganych jest 16 cykli zegara systemowego. Wpływa
to niekorzystnie na przepustowość zaprojektowanego układu.
Jeśli podstawowym celem jest zaprojektowanie układu o jak największej szybkości
szyfrowania lepszym rozwiązaniem jest implementacja 16 rund działających jako
jeden blok kombinacyjny. Tego typu optymalizacja jest znana jako rozwijanie pętli
(loop unroling).
Rozwijanie pętli jest jedną z podstawowych technik optymalizacyjnych
wykorzystywanych przez kompilatory. W przypadku realizacji w układach
reprogramowalnych pozwala ona na zaprojektowanie systemu o dużym stopniu
zrównoleglenia obliczeń. Jednakże rozwijanie pętli zwiększa rozmiar układu, co
może mieć negatywny wpływ na częstotliwość taktowania układu. W praktyce
istnieje pewna granica w rozwijaniu pętli po przekroczeniu, której nie uzyskuje się
przyrostu szybkości działania.
Mariusz Rawski
51
Schemat blokowy
•
Bloki REG na wejściach i wyjściu układu
reprezentują rejestry.
•
Dla ułatwienia opisu wprowadzono
sygnały l_slices, r_slices, c_slices,
d_slices i shift_slices reprezentujące
warstwy połączeń między kolejnymi
blokami rund algorytmu.
Mariusz Rawski
52
library ieee;
use ieee.numeric_std.all;
entity des_unrolled
port(
clk
:
rst
:
plain_data
:
key
:
ciphered_data :
);
end;
is
in std_logic;
in std_logic;
out std_logic_vector(1 to 64)
architecture RTL of des_unrolled is
type
type
type
type
type
SHIFT_ARRAY
C_ARRAY
D_ARRAY
R_ARRAY
L_ARRAY
Mariusz Rawski
is
is
is
is
is
array
array
array
array
array
(1
(1
(1
(1
(1
to
to
to
to
to
16)
17)
17)
17)
17)
of
of
of
of
of
std_logic;
std_logic_vector
std_logic_vector
std_logic_vector
std_logic_vector
(1
(1
(1
(1
to
to
to
to
28);
28);
32);
32);
53
signal
signal
signal
signal
signal
r_slices
l_slices
c_slices
d_slices
shift_slices
:
:
:
:
:
R_ARRAY;
L_ARRAY;
D_ARRAY;
C_ARRAY;
SHIFT_ARRAY;
signal
signal
signal
signal
data_perm
key_perm
data_final
last_rund_res : std_logic_vector(1
to
to
to
to
64);
56);
64);
64);
signal plain_data_reg : std_logic_vector(1 to 64);
signal key_reg
signal data_final_reg : std_logic_vector(1 to 64);
component des_rund
port(
shift_i
: in std_logic;
r_i, l_i : in std_logic_vector(1
c_i, d_i : in std_logic_vector(1
r_o, l_o : out std_logic_vector(1
c_o, d_o : out std_logic_vector(1
);
end component;
Mariusz Rawski
to
to
to
to
32);
28);
32);
28)
54
process(clk, rst)
begin
if rst = '1' then
plain_data_reg <= (others => '0');
key_reg
<= (others => '0');
data_final_reg <= (others => '0');
plain_data_reg <= plain_data;
key_reg
<= key;
data_final_reg <= data_final;
end if;
end process;
in_data
=> plain_data_reg,
);
last_rund_res <= r_slices(17) & l_slices(17);
in_data
=> last_rund_res,
out_data => data_final
);
in_data
=> key_reg,
);
Mariusz Rawski
55
l_slices(1)
r_slices(1)
c_slices(1)
d_slices(1)
<=
<=
<=
<=
data_perm(1 to 32);
data_perm(33 to 64);
key_perm(1 to 28);
key_perm(29 to 56);
rund_slices:
bi : des_rund port map(
shift_i => shift_slices(i),
r_i
=> r_slices(i),
l_i
=> l_slices(i),
c_i
=> c_slices(i),
d_i
=> d_slices(i),
r_o
=> r_slices(i+1), l_o
=> l_slices(i+1),
c_o
=> c_slices(i+1), d_o
=> d_slices(i+1)
);
shift_by_1:
if (i = 1) or (i = 2) or (i = 9) or (i = 16) generate
shift_slices(i) <= '0';
end generate;
shift_by_2:
if ((i > 2) and (i < 9)) or ((i > 9) and (i < 16)) generate
end generate;
end generate;
ciphered_data
end;
Mariusz Rawski
<= data_final_reg;
56
Realizacja kombinacyjna algorytmu DES – wyniki
Fitter Summary
des_unrolled
Family
Stratix
Device
EP1S10F484C5
3,968 / 10,570 ( 38 % )
Total pins
194 / 336 ( 58 % )
Total virtual pins
0
Total memory bits
0 / 920,448 ( 0 % )
0 / 48 ( 0 % )
Total PLLs
0/6(0%)
Total DLLs
0/2(0%)
Przepustowość dla wersji kombinacyjnej:
thruput unroll = fMAX × data_size
thruput unroll = 940,8 Mbit/s
wczytanie danych
szyfrogram gotowy
Mariusz Rawski
wczytanie klucza
szyfrogram gotowy
57
Realizacja potokowa
•
Rejestry oddzielające rundy algorytmu
skracają ścieżkę krytyczną
Mariusz Rawski
58
Realizacja potokowa algorytmu DES – VHDL (1)
●●●
entity des_pipelined is
port(
clk
: in std_logic;
rst
: in std_logic;
plain_data
key
ciphered_data : out std_logic_vector(1 to 64)
);
end;
architecture RTL of des_pipelined is
type SHIFT_ARRAY is array (1 to 16) of std_logic;
type C_ARRAY
is array (1 to 17) of std_logic_vector
type D_ARRAY
type R_ARRAY
type L_ARRAY
signal
signal
signal
signal
signal
signal
signal
signal
signal
shift_slices :
r_slices
:
l_slices
:
c_slices
:
d_slices
:
r_slices_reg :
l_slices_reg :
c_slices_reg :
d_slices_reg :
SHIFT_ARRAY;
R_ARRAY;
L_ARRAY;
D_ARRAY;
C_ARRAY;
R_ARRAY;
L_ARRAY;
D_ARRAY;
C_ARRAY;
(1
(1
(1
(1
to
to
to
to
28);
28);
32);
32);
Sygnały opisujące rejestry potoku
●●●
Mariusz Rawski
59
begin
process(clk, rst)
begin
if rst = '1' then
r_slices_reg <=
l_slices_reg <=
c_slices_reg <=
d_slices_reg <=
(others
(others
(others
(others
=>
=>
=>
=>
r_slices_reg <= r_slices;
l_slices_reg <= l_slices;
c_slices_reg <= c_slices;
d_slices_reg <= d_slices;
end if;
end process;
(others
(others
(others
(others
=>'0'));
=>'0'));
=>'0'));
=>'0'));
Proces modelujący rejestru potoku
in_data => plain_data,
);
in_data => key,
);
Mariusz Rawski
60
last_rund_res <= r_slices_reg(17) & l_slices_reg(17);
in_data => last_rund_res, out_data => data_final
);
l_slices(1)
c_slices(1)
<= data_perm(1 to 32); r_slices(1) <= data_perm(33 to 64);
<= key_perm(1 to 28); d_slices(1) <= key_perm(29 to 56);
rund_slices:
bi : des_rund port map(
shift_i => shift_slices(i),
r_i
=> r_slices_reg(i), l_i
=> l_slices_reg(i),
c_i
=> c_slices_reg(i), d_i
=> d_slices_reg(i),
r_o
=> r_slices(i+1), l_o
=> l_slices(i+1),
c_o
=> c_slices(i+1), d_o
=> d_slices(i+1)
);
shift_by_1:
if (i = 1) or (i = 2) or (i = 9) or (i = 16) generate
end generate;
shift_by_2:
if ((i > 2) and (i < 9)) or ((i > 9) and (i < 16)) generate
end generate;
end generate;
ciphered_data <= data_final;
end;
Mariusz Rawski
61
Realizacja potokowa algorytmu DES – wyniki
Fitter Summary
des_pipelined
Family
Stratix
Device
EP1S10F484C5
4,566 / 10,570 ( 43 % )
Total pins
194 / 336 ( 58 % )
Total virtual pins
0
Total memory bits
0 / 920,448 ( 0 % )
0 / 48 ( 0 % )
Total PLLs
0/6(0%)
Total DLLs
0/2(0%)
Przepustowość dla wersji potokowej:
thruput pip= fMAX × data_size
thruput pip= 10 917,76 Mbit/s = 10, 91 Gbit/s
wczytanie danych
szyfrogram gotowy
Napełnianie potoku
Mariusz Rawski
62
Wyniki
fMAX
Zasoby
Wydajność
[MHz]
[# LC]
[Mbit/s]
−
−
183,91
DES iter
151,54
449
604
DES unroll
14,75
3 968
940,8
DES pip
170,59
4 566
10 917,76
DES
soft
Każda realizacja sprzętowa jest wydajniejsza od
wersji programowej
Projektant ma możliwość balansu pomiędzy
wielkością wymaganych zasobów a wydajnością
systemu sprzętowego
Mariusz Rawski
63

Iteracyjna realizacja algorytmu DES – VHDL

Transkrypt

Podobne dokumenty

www.sklepswiatek.pl

to get the file

www.sklepswiatek.pl

case logic torba na aparat tbc404k

Modelowanie i symulacja systemów cyfrowych Laboratorium 5

CASE LOGIC ETUI NA LAPTOPA 16 LAPS116K