UNIVERSITATEA TEHNICĂ „Gheorghe Asachi” din IAȘI

FACULTATEA DE AUTOMATICĂ ȘI CALCULATOARE

DOMENIUL: CALCULATOARE ȘI TEHNOLOGIA
INFORMAȚIEI SPECIALIZAREA: CALCULATOARE

LUCRARE DE DIPLOMĂ

Absolvent

Mihai Alexandru Olaru

Coordonator științific
Conf. Dr. Ing. Andrei Stan

Iași, 2019
 DECLARAȚIE DE ASUMARE A AUTENTICITĂȚII
LUCRĂRII DE LICENȚĂ

Subsemnatul(a) OLARU MIHAI ALEXANDRU ,

CI MZ 297232
legitimat(ă)cu seria nr. ,CNP
1960626226715

DEZVOLTAREA UNUI MODUL DE CRIPTARE AES

autorul lucrării
IMPLEMENTAT PE FPGA

elaborată în vederea susținerii examenului de finalizare a studiilor de licență organizat de

către Facultatea de Automatică și Calculatoare din cadrul Universității
Tehnice „Gheorghe Asachi” din Iași, sesiunea IULIE a anului universitar
2019 , luând în considerare conținutul Art. 34 din Codul de etică universitară
al Universității Tehnice „Gheorghe Asachi” din Iași (Manualul Procedurilor,
UTI.POM.02 – Funcționarea Comisiei de etică universitară), declar pe proprie
răspundere, că această lucrare este rezultatul propriei activități intelectuale, nu conține
porțiuni plagiate, iar sursele bibliografice au fost folosite cu respectarea legislației
române (legea 8/1996) și a convențiilor internaționale privind drepturile de autor.

Data Semnătura
Cuprins
Structura internă AES.....................................................................................................................7
SubBytes și InvSubBytes.........................................................................................................9
MixColumn și InvMixColumn..............................................................................................10
ShiftRows și InvShiftRows....................................................................................................10
AddRoundKey.......................................................................................................................10
KeySchedule..........................................................................................................................11
Integrarea modulelor de bază.....................................................................................................11
AES – Mediu de Verificare........................................................................................................12
Resurse Hardware Folosite........................................................................................................13
Simulare Formă de undă............................................................................................................13
Bibliografie................................................................................................................................13
 Dezvoltarea unui modul de criptare
AES implementat pe FPGA
Olaru Mihai Alexandru

Rezumat

Lucrarea de față își propune studierea și implementarea într-o manieră hardware a unui
modul de criptare folosind AES (Advanced Encryption Standard) și sintetizarea acestuia pe un
FPGA.

AES este cel mai folosit algoritm simetric de criptare, datorită faptului că se poate
implementa relativ ușor în software și cu un cost redus în hardware.

Ca și specificații, AES lucrează cu blocuri de intrare pe 128 de biți, lungimea cheii poate
fi 128, 192, 256 biți, la baza sunt fundamente matematice din corpuri finite (Galois Fields), iar
algoritmul se termină după executarea unui număr de runde, în funcție de lungimea cheii.

În analiza lui s-au observat mai multe direcții precum: dezvoltarea unei arhitecturi
pipeline, fără feedback pentru a obține viteză de zeci de GigaBits pe secundă (mai ales pentru
criptarea canalelor de comunicare). A doua direcție a fost dezvoltarea unu arhitecturi compacte și
optimizarea unor bucăți din algoritm pentru a obține un cost minim (hardware). O altă tendință a
fost reutilizarea componentelor în operațiile de bază ale algoritmilor și descompunerea lor în
părți compune astfel încât, acceeași componentă să poată fi folosită și în procesul de criptare dar
și în cel de decriptare.

Ca și arhitectură, se va folosi o metodă de tip pipeline, modulul incapsulând câte o unitate

de calcul pentru fiecare strat de calcul: Key Addition Layer, Byte Subtitution layer (S-box),
Diffusion Layer cu ShiftsRows, MixColumn sublayers.

În paralel cu modul de criptare, se va dezvolta și mediu de verificare de bază pentru unele

componente interne.

La nivel de aplicație se urmărește integrarea modului ca periferic și realizarea unui

criptări/decriptări de date în funcție de cererile primite de la un master. Generarea traficul de date
și colectarea datelor de ieșire va fi realizat de către master, modulul AES fiind responsabil doar
de tehnica de calcul a algoritmului. Prin această metodă, masterul nu va folosi putere de calcul
suplimentară pentru securizarea datelor, ci doar va folosi doar un timp de comunicare (scrieri și
citiri din memorie/regiștri).
Matematică: Introducere în Galois Fields
În AES, aritmetica Galois este cea mai folosită în alcătuirea straturilor. În acest capitol se va
prezenta o scurtă introducere în teoria corpurilor finite.
Un corp finit, denumit și Galois Field, este un set cu un număr finit de elemente. Pe scurt, corpul
este un set de elemente unde putem aduna, scădea, înmulți și inversa. Înainte de a introducere
noțiunea de corp, avem nevoie de un concept pentru o structură algebrică simplă, denumită grup.
Grupul este un set de elemente, G care împreună cu o operație binară notată cu * satifac
următoarele trei proprietăți:
 Asociativitate: pentru oricare a, b, c care fac parte din G,
a*(b*c)=(a*b)*c
 Există un element netru e, pentru oricare ar fi a aparținând grupului G
a*e=e*a =a
 Pentru oricare element a din G, exista un element invers a-1 din G astfel
a * a-1 = a-1 * a = e
Dacă pentru oricare elemente a, b din G este îndeplinită și condiția a * b = b * a atunci acest grup
se numește grup abelian(comutativ).
De exemplu dacă un grup are o operație numită adunare, atunci operația inversă este scădere.
Dacă operația este înmulțirea, operația inversă este împărțirea (sau înmulțirea cu un element
invers).
Un exemplu de grup poate fi mulțimea G = {1, 2, 3, 4, 5} și operația de adunare mod 6.
Elementul neutru este elemental neutru al operației de adunare, adică 0. Operația de adunare este
asociativă. Fiecare element a din G are un invers –a astfel încât a + (-a) = 0 mod 6.
Pentru a avea toate cele patru operații de bază (adunare, scădere, înmulțire, împărțire) într-o
singură structură, avem nevoie de o mulțime care să conțină un grup aditiv și unul multiplicativ.
Această structură se numește corp(Field)
Corpul este un set de elemete F ce are următoarele proprietăți:
 Toate elementele din F formează un grup aditiv cu operația ”+” și element neutru 0.
 Toate elementele din F excepție, făcând 0, formează un grup multiplicativ cu operația
grupului ”X” și element neutru 1.
 Când două operații din grup sunt amestecate se plică legea distributivității astfel, pentru
a, b, c ∈ F : a(b + c) = (ab) + (ac)
Exemplu: Mulțimea numerelor reale este un corp cu element neutru 0 pentru grupul aditiv și
element neutru 1 pentru grupul multiplicativ. Fiecare număr a are un aditiv invers, numit –a, și
fiecare număr a nenul are un multiplicativ invers pe 1/a.
În criptografie interesul se pune întotdeauna pe corpurile cu număr finit de elemente, ce sunt
numite și corpuri finite (Finite fields sau Galois fields). Numărul de elemente dintr-un corp se
numește ordin sau cardinalul corpului.
Una dintre teoremele fundamentale pentru corpuri spune că un corp de ordin m există doar dacă
m este o putere a unui număr prim, m = p n. Această teoremă ne indică faptul că pot exista
corpuri finite cu 13 elemente, sau 27 (27 = 3 3), dar nu poate exista un corp finit cu 10 elemente
pentru că 10 este egal cu 2*5, deci 10 nu este putere a unui număr prim. În continuare, accentul
se va pune pe cum arată corpurile finite și un alt aspect important pentru criptografie este
aritmetica acestora.

Corpuri Prime
Corpurile prime sunt cele mai intuitive exemple de corpuri finite, adică corpuri unde n=1.
Elementele corpurilor GF(p) pot fi reprezentate de întregii 0, 1, ..., p-1. Cele două operații ale
acestui corp sunt adunarea mod p și înmulțirea mod p.
Fie p un număr prim. Atunci GF(p) este un corp prim, sau un corp finit, corp Galois cu un număr
prim de elemente. Toate elementele diferite de 0 din GF(p) au un invers. Aritmetica în GF(p) este
făcută mod p.
Pentru a realiza operațiile de bază într-un corp prim, trebuie să urmăm regulile următoare:
adunarea și înmulțirea sunt realizate mod p, inversul aditiv pentru oricare element a este dat de
relația a + (-a) = 0 mod p, și cel multiplicativ al elementelor nenule este definit prin a * a-1 = 1.
Ca și exemplu se considera GF(5) = {1, 2, 3, 4}. Tabelele de mai jos descriu cum se pot realiza
operațiile pentru fiecare element din corp.

Adunare
+ 0 1 2 3 4 Adunare invers
0 0 1 2 3 4 −0 = 0
1 1 2 3 4 0 −1 = 4
2 2 3 4 0 1 −2 = 3
3 3 4 0 1 2 −3 = 2
4 4 0 1 2 3 −4 = 1

Înmulțire 4 0 4 3 2 1
Înmulțire invers
X 0 1 2 3 4
0 0 0 0 0 0 0−1 nu există
1 0 1 2 3 4 1−1 = 1
2 0 2 4 1 3 2−1 = 3
3 0 3 1 4 2 3−1 = 2
4−1 = 4
Un simplu și foarte important exemplu este dat de GF(2). Elementelui acestui corp de ordin doi
sunt 0 și 1, și operațiile disponibile sunt sub forma următoare:
Adunare Înmulțire
+ 0 1 x 0 1
0 0 1 0 0 0
1 1 0 1 0 1

Adunarea în GF(2) este echivalent cu o poartă XOR, iar înmulțirea este echivalentă cu o poartă
ȘI.

Extinderi Galois
În AES, corpul finit folosit are 256 de elemente și este descris ca fiind GF(2 8). Acest corp este
ales pentru că fiecare element poate fi reprezentat pe un byte. Fiecare byte de dată este tratat ca
un element individual din GF(28) și manipulează datele făcând calculele aritmetice în acest corp
finit.
Dacă ordinul acest ordin a corpului finit nu este prim, 2 8 nu este prim, adunarea și înmulțirea nu
poate fi reprezentată de și adunare și scăderea modulo 2 8. Pentru acest tip de corpuri finite, se
folosesc notații diferite și reguli de calcul diferit. Pentru a calcula exdinderea corpului, elemente
pot fi reprezentate ca și polinoame cu coeficienți în GF(2). Gradul polinomului folosit pentru
AES este 7 deoarece aceste este reprezentat în GF(28). Fiecare element poate fi reprezentat în
maniera următoare:
Fie elementul A din GF(28), A poate fi scris sub forma A(x) = a7x7+ ... a1x + a0, ai fiind
din GF(2) = {0, 1}. Este important de observat că fiecare polinom poate fi simplu salvat sub
formă de un vector de 8 biți (1 byte). Puterea lui x se deduce din poziția bitului în vector.
A = (a7, a6, a5, a4, a3, a2, a1, a0)

Structura internă AES

Algoritmul operează cu blocuri de date pe 128 de biți și acceptă 128, 192, 256 biți pentru
lungimea de cheie. Acesta este un algoritm iterativ simetric, ceea ce înseamnă că atât criptarea
cât și decriptarea datelor constau în multiple iterații ale acelorași runde de bază.
Pentru fiecare rundă se folosește o nouă cheie internă, numărul de runde depinzând de
dimensiunea cheii primită ca dată de intrare. Acesta este egal cu 10, 12, sau 14 pentru o cheie
128, 192, 256 biți. La baza fiecărei runde stau operații de înlocuiri, permutări aplicate asupra
tuturor biților. Pentru o bună înțelegere a algoritmului, datale de intrare sunt reprezentate pe o
matrice de 4x4 octeți. Acest bloc de octeți aranjat într-o maniera pătratică este reprezentarea de
stare. Starea(State) este exemplificată în Figura 1.1.
Fig.1.1 Reprezentarea internă blocului de date sub forma matricială

AES-ul operează cu elementele, coloanele sau rândurile din matrice curentă de stare.
Similiar, octeții din cheie se aranjează într-o matrice cu patru rânduri și patru(128 biți), șase(192
biți) sau opt(256 biți) coloane.

Runda conține patru operații principale: SubBytes, ShiftRows, MixColumn, și

AddRoundKey. Deoarece algoritmul acesta se bazează puternic pe teoreme matematice(SP-
network) acesta necesita și existența unor versiune pentru decriptare a funcțiilor de bază:
InvAddRoundKey, InvMixColumn, InvShiftRows, InvSubBytes. Structura internă a rundei
pentru criptare și cea pentru decriptare sunt arătate în Figura 1.2.

Pentru runda finală din algoritm renunță la operația de MixColumn respectiv

InvMixColumn.
Fig 1.2 Structura unei runde pentru criptare și decriptare

SubBytes și InvSubBytes

Operația SubBytes este o transformare individuală a fiecărui byte din starea internă.
Această operație este compusă din două operții de bază :

 Calcularea inversului octetului în GF(28). Elementrul {0x00} este conservat.

 Transformare afină peste GF(2) calculată cu următoare ecuație b’= f(b) XOR
c, unde f este descrisă în ecuația din Figura 1.3(stânga), b este inversul
octetului iar c este o constantă egală cu 0x63. Pentru operația inversă
(InvSubBytes) se folosește ecuația din Figura 1.3(dreapta).

Fig 1.3 Ecuația pentru calculul transformatei afine.pentru SubBytes(stânga) și

InvSubBytes(dreapta)
MixColumn și InvMixColumn

MixColumn și InvMixColumn fac parte din stratul de difuzie, astfel simpla

modificare a unui bit intr-un octet trebuie să influențeze calculul celorți octeți. Această
operație este o transformată liniară ce amestecă coloane matricei de stare. Fiecare octet de
intrare influențează cei patru octeți de ieșire. Adunarea și înmulțirea sunt calculate în GF(2 8).
Formula pentru o coloană poate fi calculată sub formă de matrice (Figura 1.5 și Figura 1.6 ).

Fig 1.3 Ecuația pentru funcția MixColumn

Fig 1.3 Ecuația pentru funcția InvMixColumn

ShiftRows și InvShiftRows

Cele două funcții au rolul de a realiza un set de permutări pe rând în matrice de stare.
Atfel încât primul rând nu se permută, rândul al doile se permută cu o poziție la stânga,
rândul al treilea cu două poziții la stânga, iar ultimul rând se permută cu trei poziții la stânga.

AddRoundKey

Cele două date de intrare pentru această funcție sunt matricea curentă de stare și cheia internă
curentă. Cele două date de intrare sunt combinate folosind operația XOR. Această operație
este echivalentă cu adunarea in GF(2).
KeySchedule

Managementul cheii interne folosește ca date de intrare cheia originală preluată de la un

utilizator (lungime de 128, 192 sau 256 biți). De la această cheie, se generează în mod
recursiv câte o cheie internă pentru fiecare rundă. Procesul de generare al cheii este orientat
pe cuvânt, unde cuvântul are este de 32 de biți. Cheile interne sunt salvate într-un vector W
cu elementele W[0], W[1], ... , W[43]. Elementele K 0, ..., K15 arata octeții din cheia originală.
Inițial, cheia originală este copiată în primele patru cuvinte ale vectorului W. Pe rundă se
calculează câte patru cuvinte după cum urmează, folosind următoarele reguli:

W[4i] = W[4(i-1)] + g(W[i-1]), i = 1, ..., 10.

g – este o funcție neliniară ce primește ca parametri de intrare patru octeți. Octeții sunt rotiți,
după care se aplică o transformare S-box și se adună(XOR pe biți) coeficienții rundei.
Coeficienții pe rundă sunt generați astfel:
RC[1] = x0 = (00000001)2,
RC[2] = x1 = (00000010)2,
...
9
RC[10] = x = (00110110)2
Celelalte trei cuvinte din W sunt calculate astfel:
W[4i + j] = W[4i + j – 1] + W[4(i-1) + j], i = 1, ..., 10; j = 1, 2, 3

Integrarea modulelor de bază

Runda poate fi implementată ușor folosind paralelizarea. Astfel, datele de intrare sunt
orientate pe octeți dela cel mai semnificativ octet către cel mai puțim semnificativ. O rundă
este compusă din șaisprezece 8-bit S-box care calculează funcția SubByte și patru 32-bits
MixColumns operații, aceastea putând lucra independent. Singura operație ce necesită cei
128-biți de intrare este ShiftRows. Pentru a putea salva rezultatele intermediare se vor folosi
unii regiștri suplimentari.
Pentru a putea crește performanțele legate de numărul de octeți criptați pe secundă se va
apela la o filosofie pipeline, pentru că modulele ce execută funcțiile de bază nu sunt folosite
în același timp pe parcursul unei runde, execuția lor fiind una secvențială. Pentru posibilă
arhitectura de tip pipeline, se vor adaugă în câteva locații strategice niște regiștri de stare.
Astfel timpul de criptare se poate imbunătăți. Arhictura modului top este prezentată în figura
de mai jos.
 Bibliografie

Fig. 1.4 – Arhitectura modulului AES

AES – Mediu de Verificare

Pentru verificare componentelor și pentru a evita eventualele erori de design, se construiește
în paralel cu modulul AES de criptare și un mediu de verificare ce este capabil să introducă
stimuli în RTL și să compare valorile capturate ca și date de ieșire, cu unele valori așteptate.
Mediul de verificare folosește valori precalculate din diferite tabele de valori.

Fig 1.5 – Mediu De verificare

Resurse Hardware Folosite
Digilent Zybo Z2 – FPGA

Simulare Formă de undă

Bibliografie

[1] Çetin Kaya Koç. Cryptographic Engineering. Springer, 2008.

[2] Christof Paar. Understanding Cryptography.Springer, 2010.
[3] Vincent Rijmen.The Design of Rijndael AES – The Advanced Ecryption Standard. Spriger 2002