Contribuții în proiectarea unităților centrale utilizate în arhitecturi de calcul dedicate

Transcription

1 UNIVERSITATEA TEHNICĂ GHEORGHE ASACHI DIN IAȘI Facultatea de Automatică și Calculatoare Contribuții în proiectarea unităților centrale utilizate în arhitecturi de calcul dedicate REZUMATUL TEZEI DE DOCTORAT Contributions in designing central processing units used in dedicated computing architectures PH.D. Thesis summary Conducător de doctorat Prof. univ. dr. ing. Alexandru Valachi Doctorand Asist. ing. Andrei Stan IAȘI 2011

2

3

4

5 Cuprins Cuprins Introducere Motivație Structura tezei Sisteme de calcul dedicate Introducere Caracteristici ale sistemelor de calcul dedicate Caracteristici structurale și funcționale Caracteristici non-funcționale Sisteme de calcul dedicate cu microcontroler Automate finite Opțiuni de implementare Model de automat finit pentru sisteme dedicate Automat finit cu mecanism de siguranță Bibliotecă de funcții pentru criptare Metode de criptare Algoritmi de criptare Evaluarea implementării algoritmilor de criptare Arhitectură pentru securizarea sistemelor dedicate Exemplu de utilizare a metodei propuse Conversie de cod în virgulă mobilă în cod în virgulă fixă Proiectarea aplicației de conversie a codului Transformarea fluxului de date Tehnici folosite în proiectarea aplicației Generarea codului Evaluarea metodei propuse Concluzii Sisteme de calcul dedicate cu circuite digitale reconfigurabile Sisteme reconfigurabile Spatial computing Structură pentru monitorizarea timpului de execuție al subprogramelor Studii similare Arhitectura structurii de monitorizare Evaluarea structurii de monitorizare

6 4.4 Structură pentru monitorizare a execuției aplicațiilor pe un MPSoC Arhitectura sistemului MPSoC Arhitectura structurii de monitorizare Arhitectură pentru transformarea dinamică a codului în module hardware Arhitectura sistemului reconfigurabil Algoritmii de funcționare pentru sistemul reconfigurabil Concluzii Structură autotestabilă pentru memoriile RAM Defecte de memorie Notaţii folosite în descrierea testelor de memorie Testul de memorie MarchS2C Comparație cu alți algoritmi de testare March Structuri autotestabile Proiectarea logicii de testare Logica de generare a adresei Logica de generare a datelor şi de verificare Logica de control microprogramată Concluzii Concluzii Contribuții personale Diseminare rezultate Sumar publicaţii Detalii publicaţii Direcții viitoare de cercetare Bibliografie... 74

7 1 Introducere 1.1 Motivație Calculatoarele și tehnologia informației au avut un impact major în evoluția societății umane în cursul ultimilor zeci de ani. Această influență se va face simțită și în viitor având în vedere că aceste tehnologii au un rol important și o utilizare largă în infrastructura societății actuale. Datorită legăturilor create între societate și tehnologie, evoluția societății este strâns acompaniată de evoluția tehnologică. În privința calculatoarelor și tehnologiei informației, tendințele actuale sunt reprezentate de un interes foarte ridicat pentru acces la informație prin multiple medii, servicii personalizate și servicii de realitate virtuală de înaltă calitate. Simultan, se constată o decuplare a proceselor de calcul și cele de stocare a informației în paralel cu o creștere semnificativă a centrelor de procesare a datelor (engl. data processing centers). Aplicațiile domestice, roboții, mijloacele de transport autonome, sistemele de teleprezență și alte aplicații curente sunt exemple de tehnologii care susțin și cauzează schimbări în societate. Dezvoltarea acestor tehnologii și aplicații sunt influențate de tendințe din mediul economic precum presiunea exercitată de costuri, restructurarea industriilor, modele de afaceri orientate către servicii, convergența funcționalității dispozitivelor electronice și mediul cooperativ de dezvoltare al aplicațiilor. Provocările la care trebuie să răspundă sistemele de calcul dedicate (sunt denumite și sisteme de calcul încorporate engl. embedded) sunt generate de mai multe surse (Duranton, et al., 2010). Caracteristicile aplicațiilor Schimbări ale societății Provocări tehnologice Aspecte economie Constrângeri tehnologice Figura Surse ale provocărilor tehnologice pentru sistemele de calcul dedicate, (Duranton, et al., 2010) Proiectarea sistemelor de calcul pentru crearea tehnologiilor și implementarea aplicațiile secolului 21 se confruntă cu următoarele constrângeri tehnologice: 7

8 Introducere Partea hardware are o flexibilitate comparabilă sau mai ridicată decât partea software a unui sistem de calcul. Puterea consumată este o metrică a performanței sistemelor. Caracteristicile comunicațiilor sunt o metrică a performanței sistemelor. Circuitele de tip ASIC devin neatractive economic. Proiectarea circuitelor ASIC pentru condițiile cele mai defavorabile conduce la faliment. Sistemele complexe trebuie să se bazeze pe componente nefiabile. Timpul devine relevant. Sistemele de calcul sunt supuse atacurilor în mod continuu. Paralelismul pare să fie dificil de exploatat eficient. Legea lui Moore are un sfârșit. 1.2 Structura tezei Teza este structurată în șase capitole al căror conținut este prezentat în continuare. În capitolul unu este prezentată motivația abordării temei propuse cu precizarea surselor provocărilor tehnologice la care trebuie să răspundă sistemele de calcul dedicate. În capitolul al doilea sunt prezentate elementele caracteristice ale arhitecturilor sistemelor de calcul dedicate. Este prezentată o clasificare a arhitecturilor sistemelor de calcul, precum și o structură generală pentru arhitectura sistemelor de calcul dedicate. Sunt enumerate trăsături specifice care trebuie considerate în proiectarea sistemelor dedicate și modele pentru dezvoltarea de aplicații pentru acest tip de sisteme. De asemenea, sunt amintite și standarde folosite în certificarea și validarea implementării sistemelor de calcul dedicate utilizate în sisteme cu cerințe speciale de siguranță în funcționare. Capitolul al treilea prezintă proiectarea de module software utilizate în dezvoltarea aplicaților software pentru sisteme de calcul dedicate cu microcontroler. Modulele implementate sunt evaluate prin măsurarea unor caracteristici precum timpul de execuție, cantitatea de memorie utilizată sau consumul de energie. Este prezentată proiectarea unui modul software care implementează un model computațional de tip automat finit. Acest modul este extins cu adăugarea unui mecanism de siguranță pentru prevenirea blocării automatului finit. Al doilea modul software proiectat conține algoritmi de criptare, cu diverse performanțe de securizare a informațiilor, care sunt evaluați prin estimarea consumului de energie necesar execuției lor pe un sistem dedicat. Este propusă utilizarea acestor algoritmi într-o arhitectură adaptivă de securizare a sistemelor dedicate prin care se obține o scădere a consumului de energie prin adaptarea algoritmilor de criptare la condițiile de operare. Al treilea modul proiectat este o aplicație de generare de cod pentru optimizarea implementării filtrelor digitale folosind numai operanzi și operații cu numere întregi. Aplicația poate genera mai multe soluții folosind o funcție de cost în care sunt luate în considerare complexitatea calculelor și acuratețea rezultatului. Capitolul al patrulea prezintă proiectarea de arhitecturi de sisteme de calcul dedicate care folosesc circuite reconfigurabile. Sunt proiectate două structuri de monitorizare hardware care pot fi incluse în sistemele dedicate pentru a crește nivelul de siguranță în funcționare. Structurile de monitorizare urmăresc comportamentul temporal al execuției aplicațiilor. Prima structură monitorizează timpul de execuție al rutinelor care sunt apelate în timpul rulării aplicațiilor de către un microprocesor, iar cea de a doua structură monitorizează transferurile de informații care au loc într-un sistem multiprocesor. Arhitecturile de monitorizare sunt evaluate pe sisteme cu circuite reconfigurabile FPGA (engl. Field Programmable Gates Array). Tot în acest capitol este prezentată o arhitectură pentru un sistem de calcul capabil să monitorizeze și să evalueze execuția unei aplicații de către un microprocesor pentru a genera apoi module hardware care implementează funcționalități identice cu porțiuni din codul aplicației monitorizare.

9 Introducere Capitolul al cincilea prezintă proiectarea unui modul de memorie autotestabil. Este prezentată proiectarea unui test de memorie de tip March capabil să detecteze toate defectele de tip cuplaj între două celule de memorie. Se demonstrează că acest test acoperă toate tipurile de defectele de tip cuplaj între două celule, precum și optimalitatea testului relativ la numărul de operații de scriere și citire necesar pentru a detecta defectele. Este realizată și o analiză comparativă cu alte teste de memorie din care reiese eficiența testului propus. Acest algoritm este implementat într-un modul al unei structuri autotestabile cu cale de control microprogramată. Capitolul al șaselea prezintă concluziile tezei, contribuțiile personale, diseminarea rezultatelor, precum și direcțiile viitoare de cercetare.

10

11 2 Sisteme de calcul dedicate 2.1 Introducere Evoluția sistemelor de calcul a condus la trei categorii principale (Hennessy & Patterson, 2007) caracterizate de aplicațiile pe care le rulează, cerințele la care trebuie să facă față și tehnologiile folosite la implementare. Tabelul Tipuri de sisteme de calcul și criterii de clasificare, după (Hennessy & Patterson, 2007) Caracteristică Desktop Server Sisteme dedicate Preț sistem $ $ $ Preț microprocesor $ $ $ Cerințe de proiectare speciale Raport preț/performanță Performanțe grafice Disponibilitate, Scalabilitate, Rata de răspuns Preț, Putere consumată, performanțe specifice aplicației Bucăți vândute Sistemele de calcul dedicate reprezintă categoria cu creșterea cea mai rapidă. Aceste sisteme sunt prezente în aplicații de consum, de la cuptoare cu microunde până la telefoane mobile și console de jocuri. Sistemele dedicate au cea mai largă plajă pentru costuri și puterea de calcul disponibilă. În construcția lor sunt utilizate microprocesoare ieftine pe 8 sau 16 biți sau microprocesoare pe 32 de biți cu performanțe de 100 MIPS la un cost de 5$. Tipurile de microprocesoare disponibile pentru sistemele dedicate sunt foarte variate ca performanțe de calcul și ca urmare prețul este un factor determinant în proiectarea acestor sisteme. Există cerințe de performanță în proiectarea acestor sisteme, însă obiectivul principal este atingerea performanțelor cu costuri minime. Sistemele de calcul dedicate sunt proiectate și construite pentru a îndeplini doar o anumită funcție sau un set restrâns de funcții înrudite. Aceste sisteme electronice fac parte din sisteme mai complexe și implementează cel mai adesea funcții de control, comunicație sau interfață cu utilizatorul (acolo unde este cazul). Datorită acestei incluziuni, sistemele de calcul dedicate se mai numesc și sisteme de calcul încorporate (engl. embedded). În continuare se va folosi termenul de sisteme de calcul dedicate pentru a denumi această categorie de sisteme de calcul. Sistemele de calcul dedicate se deosebesc de sistemele de calcul de uz general prin faptul că ele execută o singură aplicație care implementează funcțiile necesare îndeplinirii sarcinilor pentru care a fost construit sistemul dedicat. 11

12 Sisteme de calcul dedicate 2.2 Caracteristici ale sistemelor de calcul dedicate Caracteristici structurale și funcționale Sistemele de calcul dedicate sunt sisteme de calcul specializate care reprezintă părți componente ale unor sisteme mai complexe. Un sistem de calcul dedicat este alcătuit dintr-o combinație de elemente hardware și software (Stallings, 2010) care formează un nucleu de calcul proiectat special pentru realizarea unei funcții specifice (Figura 2.2.1). Figura Organizarea unui sistem de calcul dedicat (încorporat engl. embedded) (Stallings, 2010) Foarte frecvent, sistemele de calcul dedicate prezintă următoarele caracteristici funcționale care determină luarea de decizii potrivite în procesul de proiectare și implementare: Procesarea în timp real a informației. Sistemele dedicate trebuie să reacționeze în limite de timp bine definite la evenimentele provenite din mediu. Nerespectarea acestor limite poate avea consecințe neprevăzute și uneori periculoase pentru siguranța mediului și a utilizatorilor. Sunt sisteme reactive. Simt evenimente din mediu prin intermediul senzorilor și controlează mediul utilizând actuatoare. Acest fapt impune sistemelor dedicate atingerea unor performanțe în funcționare consistente cu mediul în care operează. Un sistem reactiv folosește o combinație de elemente hardware și software pentru a răspunde evenimentelor provenite din mediu cu respectarea unor constrângeri bine definite. Evenimentele externe pot fi periodice și predictibile sau aperiodice și greu de anticipat. Planificarea în vederea procesării ține cont atât de evenimentele periodice cât și de ce cele aperiodice iar performanțele execuției trebuie garantate pentru cele mai defavorabile condiții. Sunt sisteme hibride. Includ elemente hardware utilizate pentru procesări analogice (e.g. convertoare analog-numerice și/sau numeric-analogice) și elemente hardware utilizate pentru procesări digitale (e.g. numărătoare, interfețe pentru comunicații digitale). Circuitele integrate folosite în proiectarea de sisteme de calcul dedicate sunt de diverse tipuri: microcontrolere, microprocesoare, procesoare digitale de semnal sau circuite FPGA (engl. Field Programmable Gates Array). Au resurse de procesare limitate. Adesea, unitățile centrale ale sistemelor dedicate au arhitecturi simple (e.g. fără memorii cache, fără pipeline) și cantități reduse de memorie de cod și date. Datorită acestui lucru, dezvoltarea de aplicații pentru sisteme dedicate este o provocare și implementarea lor trebuie să fie foarte eficientă. Au constrângeri pentru consumul de energie Sistemele dedicate sunt frecvent folosite în aplicații pentru care autonomia energetică și disponibilitatea îndelungată (e.g. rețele de senzori) sunt calități foarte importante. Pentru a satisface aceste 12

13 Sisteme de calcul dedicate cerințe, proiectarea aplicațiilor trebuie să aibă în vedere și să implementeze tehnici pentru optimizarea consumului de energie pentru procesările efectuate. Au cerințe de siguranță în funcționare. Unele sisteme dedicate sunt incluse în sisteme complexe pentru a implementa funcții de control (e.g. în industria automobilelor: sisteme ABS sau controlul tracțiunii). Funcționarea defectuoasă a acestor sisteme poate afecta siguranța utilizatorilor și ca atare procesul de dezvoltare trebuie să prevadă mijloace și metode pentru satisfacerea unui nivel acceptabil de siguranță a implementării. Costul. Sistemele dedicate sunt sensibile la costuri. Costurile provin din surse precum: costuri de proiectare, de producție sau de mentenanță. Modelele computaționale sunt abstractizări care guvernează interacțiunile dintre componentele unui sistem. Modelele computaționale pentru proiectarea de sisteme dedicate trebuie să ofere mijloace și metode pentru exprimarea și implementarea concurenței și a comportamentului temporal. Exemple de modele computaționale utilizate pentru dezvoltarea de aplicații pentru sistemele dedicate sunt: Flux de date (engl. dataflow). Componentele aplicației sunt reprezentate de module care realizează calcule atomice asupra datelor de intrare atunci când acestea sunt disponibile. Conexiunile dintre module descriu fluxul de date de la module producător la module consumator. Execuție periodică (engl. time triggered). Componentele aplicației sunt reprezentate de module a căror activare are loc periodic la apariția unor evenimente declanșate de scurgerea unor intervale de timp cu perioadă fixă. Bazate pe evenimente (engl. event triggered). Componentele aplicației sunt reprezentate de module a căror activare are loc la apariția unor evenimente descrise de o valoare și momentul apariției. Automate finite (engl. finite state machines). Este un model computațional secvențial. Execuția unui automat presupune o singură stare activă la un moment dat Caracteristici non-funcționale Datorită integrării sistemelor dedicate ca elemente de comandă ale unor sisteme mai complexe care au cerințe severe de eficiență a funcționării, sistemele dedicate trebuie să prezinte următoarele atribute non-funcționale (Avizienis, Laprie, & Randell, 2004): disponibilitate: proprietatea sistemului de a fi capabil să ofere serviciul la un anumit moment de timp; fiabilitate: proprietatea sistemului de a fi capabil să ofere serviciul pentru un anumit interval de timp; siguranță: proprietatea sistemului de a nu provoca daune mediului, oamenilor sau alte pierderi materiale; integritate: proprietatea sistemului de a nu manifesta alterări; mentenabilitate: proprietatea sistemului de a suporta reparații sau modificări. Considerate împreună, toate aceste atribute formează noțiunea de eficiență globală (engl. dependability). Pentru a realiza unele dintre componentele eficienței globale s-au dezvoltat diverse tehnici: prevenirea defectelor prevenirea apariției sau introducerii de defecte; tolerarea defectelor funcționarea în prezența defectelor; îndepărtarea defectelor reducerea numărului și severității defectelor; prevederea defectelor estimarea numărului curent, a incidenței și a consecințelor probabile ale defectelor. 13

14

15 3 Sisteme de calcul dedicate cu microcontroler 3.1 Automate finite O definiție formală a unui automat finit (engl. Finite State Machine - FSM) este prezentată în continuare. Un automat finit este un 6-uplu (Q, Σ,, δ, λ, q 0 ) în care: Q este o mulțime nevidă, finită mulțimea stărilor; Σ este o mulțime nevidă, finită alfabetul de intrare; este o mulțime nevidă, finită alfabetul de ieșire; δ funcția de tranziție δ : Q x Σ Q; λ funcție de generare a ieșirii: o automat finit Moore λ : Q ; o automat finit Mealy λ : Q x Σ ; q 0 starea inițială. Implementarea unui automat finit implică exprimarea elementelor sale componente: stări, tranziții, intrări (e.g. evenimente sau condiții) și ieșiri (e.g. acțiuni) cu mijloace specifice mediului de implementare. Pentru o implementare hardware sunt proiectate structuri logice combinaționale pentru funcțiile δ și λ. Pentru stocarea valorii stării curente sunt utilizate registre. Dacă un automat are N i intrări binare și N o ieșiri binare, atunci alfabetul de intrare și cel de ieșire sunt spații Bool cu N i, respectiv N b dimensiuni. Implementările software ale automatelor finite permit o mai mare flexibilitate în modelarea elementelor componente ale automatelor. Utilizarea automatelor finite este una dintre metodele de bază pentru dezvoltarea aplicațiilor software executate pe sisteme dedicate oferind suport pentru etapele de proiectare și implementare din ciclul de dezvoltare al aplicațiilor. Automatele finite sunt folosite pentru a exprima dinamica unei aplicații software. Pentru a proiecta un automat finit utilizat în aplicații software pentru sisteme dedicate este necesar să se stabilească din punct de vedere funcțional componentele care fac parte din sistem și cele care sunt externe sistemului Opțiuni de implementare Pentru implementarea în software a automatelor finite există câteva abordări principale (Williams, 2006). Se are în vedere utilizarea limbajului de programare C, acesta fiind cel mai utilizat în dezvoltarea de aplicații pentru sistemele dedicate. cod secvențial direct; instrucțiuni SWITCH-CASE multiple; instrucțiuni GO-TO și etichete; 15

16 de: Sisteme de calcul dedicate cu microcontroler metode bazate pe tabele; model de dezvoltare orientat obiect. Deosebirile cele mai importante între aceste modele de implementare sunt date de modurile reprezentare ale intrărilor, ieșirilor și evenimentelor automatului finit; monitorizare a intrărilor și evenimentelor automatului finit; generare a ieșirilor automatului finit Model de automat finit pentru sisteme dedicate Automatele finite sunt printre cele mai folosite modele computaționale utilizate (Harel, 2009) în sistemele de calcul dedicate pentru a crea aplicații (i.e. engl. firmware) de calitate. Implementarea particularizată pentru o aplicație anume a automatelor finite necesită timp și este predispusă la erori. O abordare mai eficientă este proiectarea unui module sau nucleu abstract (kernel sau core) care, pe baza unei descrieri adecvate, execută un model al unui automat finit. Prin utilizarea unui astfel de nucleu, un proiectant de sisteme dedicate trebuie să specifice numai acțiunile, verificările și tranzițiile, ca simple funcții și tabele și să lase nucleul să se ocupe de ansamblul operaţiilor de gestiune internă necesare pentru a executa automatul finit. În continuare se prezintă și se descriu etapele de implementare și evaluare ale unui nucleu de automat finit cu scopul de a-l utiliza în procesul de dezvoltare al aplicațiilor software pentru sisteme de calcul dedicate (Stan, Botezatu, Panduru, & Lupu, 2009) Implementare Modelul propus pentru un nucleu de automat finit este compus din stări, evenimente sau condiții, tranziții și funcții de acțiune. Fiecare dintre aceste componente precum și modurile de implementare sunt abordate în manieră detaliată în cele ce urmează. Fiecare stare este descrisă de structura tip FSME_STATE prezentată în Figura Structura conține informații despre funcția de acțiune care este executată în această stare, numărul de tranziții din starea respectivă și o referință la un tabel care descrie tranzițiile posibile către alte stări. Informația funcției acțiune este reprezentată printr-un pointer la funcție, având în vedere faptul că acesta este un model de automat finit de tip Moore funcția de acțiune este generată atunci când se ajunge într-o stare depinde doar de stare și nu de intrările în automatul finit. // function pointer type for action (output) functions typedef void (*FSME_PF) (void); // state type typedef struct { FSME_PF Action; uint8 TransNO; FSME_TRANS * Trans; } FSME_STATE; Figura Structura de date care descrie o stare pentru un automat finit (Stan, Botezatu, Panduru, & Lupu, 2009) Tranzițiile sunt reprezentate de structura tip FSME_TRANS prezentată în Figura Această structură conține un pointer la o funcție care returnează o valoare booleană asociată cu evaluarea unei condiții sau cu apariția unui eveniment. Structura FSME_TRANS conține, de asemenea, codul stării în care va ajunge automatul finit dacă condiția testată este adevărată sau evenimentul a avut loc. Prin implementarea condiției sau evenimentului cu o funcție se obține un grad ridicat de flexibilitate pentru implementare, permițând adaptarea cu ușurință a automatului finit la cerințele aplicației. 16

17 Sisteme de calcul dedicate cu microcontroler // function pointer type for event update functions typedef uint8 (*FSME_PF_EV) (void); typedef struct { FSME_PF_EV Event; uint8 NextState; } FSME_TRANS; Figura Structura de date care descrie o tranziție pentru un automat finit (Stan, Botezatu, Panduru, & Lupu, 2009) Ultima structură specifică pentru acest model este structura FSME_FSM prezentată în Figura Ea cuprinde câmpuri care descriu o instanță a unui automat finit care este executat pe un sistem dedicat. Structura FSME_FSM conține un indicator care arată dacă automatul finit este oprit sau dacă este validată execuția acestuia, unul care indică o schimbare a stării automatului finit și câmpuri care stochează starea curentă, numărul total de stări al automatului finit și o referință la o tabelă care conține descrierile stărilor și tranzițiilor automatului finit. // FSM type typedef struct { uint8 Enable; uint8 CurrentState; uint8 StatesNO; uint8 StateChanged; FSME_STATE * States; uint8 TransNO; FSME_TRANS * Trans; } FSME_FSM; Figura Structura de date care descrie un automat finit (Stan, Botezatu, Panduru, & Lupu, 2009) Un automat finit este format dintr-o mulțime de tabele FSME_TRANS, care conțin informații despre tranzițiile din fiecare stare și o tabelă FSME_STATE, care conține toate stările automatului finit și referințele către tabelele de tranziții. De asemenea, o variabila de tip FSME_FSM este utilizată pentru a memora toate datele și toate referințele necesare ale unui automat finit (Figura 3.1.4). Enable CrtState StatesNO State Changed States (table) TransNO Trans (table) Action TransNO Trans (table)... Action TransNO Trans (table) Event NextState... Event NextState Figura Relațiile structurilor de date care descriu un automat finit Funcția pentru actualizarea stării curente a automatului finit este principala funcție a nucleului și este prezentată în Figura Funcția este apelată cu o referință la o instanță de tip FSME_FSM a unui automat finit. Se parcurge șirul de tranziții asociat stării curente și se verifică condițiile asociate cu tranzițiile. Dacă o condiție este adevărată atunci starea curentă a automatului finit este actualizată în concordanță cu valorile din tabela tranzițiilor aferente sării curente iar schimbarea de stare este semnalizată prin poziționarea indicatorului StateChanged. Imediat ce o condiție determină o schimbare de stare, funcția își încheie execuția chiar dacă există și alte condiții care pot fi adevărate. Această particularitate poate fi folosită în automatele finite complexe pentru a 17

18 Sisteme de calcul dedicate cu microcontroler implementa o prioritizare între tranziții, funcție de nevoile aplicației: tranzițiile prioritare sunt trecute pe poziții cu index mic în tabelă. start (FSME_UpdateState) /*folosire variabilă pentru a indica spre tabela de tranziții din starea curentă*/ _t = F->Trans /*folosire variabilă pentru stocarea numărului de tranziții din starea curentă */ _n = F->TransNO /*parcurgere tranziții din starea curentă*/ (; _i < _n ; _i++) FALSE TRUE FALSE /* verificare îndeplinire a condițiilor sau apariție a evenimentelor corespunzătoare tranziției curente*/ (FSME_EVENT_TRUE == _t[ _i ].Event()) TRUE /*actualizare stare curentă*/ F->CurrentState = _t[_i].nextstate /*fixare pointer către starea curentă*/ _s = &(F->States[F->CurrentState]) /*actualizare tabelă tranziții corespunzătoare stării curente*/ F->Trans = _s->trans /*actualizare număr tranziții corespunzător stării curente */ F->TransNO = _s->transno /*actualizare indicator schimbare stare*/ F->StateChanged = FSME_STATE_CHANGED stop (FSME_UpdateState) Figura Funcția de actualizare a stării curente a unui automat finit 18

19 Sisteme de calcul dedicate cu microcontroler În Figura sunt prezentate: funcția principală a nucleului de automat finit și funcția de acțiune. FSME_Action execută funcția de acțiune asociată. FSM_Run apelează cele două funcții prezentate anterior, numai în cazul în care indicatorul Enable al instanței de automat finit F este setat. void FSM_Run( FSME_FSM * F ) { if ( FSME_DISABLE == F->Enable ) { // may reset the FSM into initial state and deactivate outputs return; } FSME_UpdateState( F ); FSME_Action( F ); } static void FSME_Action( FSME_FSM * F ) { F->States[F->CurrentState].Action(); } Figura Funcția de execuție a unui automat finit (Stan, Botezatu, Panduru, & Lupu, 2009) Funcția FSM_Run poate fi introdusă într-o buclă infinită (i.e. engl. super-loop) pentru verificarea condițiilor asociate stării curente sau poate fi integrată într-un task executat de către un sistem de operare în timp real în funcție de nevoile aplicației. Figura prezintă două funcții auxiliare ale nucleului: Enable (Activare) și Disable (Dezactivare). Apelul acestor funcții setează sau resetează în mod corespunzător indicatorul Enable al instanței F cu care sunt apelate aceste funcții. void FSM_Enable( FSME_FSM * F ) { F->Enable = FSME_ENABLE; } void FSM_Disable( FSME_FSM * F ) { F->Enable = FSME_DISABLE; } Figura Funcțiile de activare și dezactivare ale unui automat finit (Stan, Botezatu, Panduru, & Lupu, 2009) Aceste funcții oferă posibilitatea activării sau dezactivării de automate finite individuale în cadrul aplicațiilor software pentru sisteme dedicate. În acest fel este posibilă realizarea unei proiectări eficiente cu mai multe automate finite, spre exemplu, un model cu automate finite dispuse și activate ierarhic. Avantajul acestei abordări nu constă numai în simplitatea și organizarea fluxului execuției programului, care este bazată pe tabele, ci de asemenea oferă posibilitatea de a completa, șterge sau actualiza descrierea fiecărei stări, fără a afecta semnificativ alte stări. Nucleul automatului finit dezvoltat ocupă doar 230 octeți de memorie de cod. Fiecare stare ocupă 5 octeți de memorie, iar fiecare tranziție consumă 3 octeți de memorie. Structura automatului finit ocupă 9 octeți de memorie Evaluarea modelului propus Pentru a evalua modelul propus al unui automat finit a fost creat un mediu adecvat. Mediul de evaluare este definit pentru microcontrolere pe 8 biți: familia de microcontrolere ATMega de la Atmel (Atmel Inc., 2011). Mediul de evaluare utilizează următoarele componente: un modul de automat finit construit pe baza modelului propus, un compilator C pentru microcontrolerul ATMega, și simulatorul integrat în IDE (IAR Systems, IAR Embedded Workbench for Atmel AVR, 2011). Un automat detector de secvență este implementat prin utilizarea modelului de automat finit propus. Acest tip de sistem secvențial este o abstractizare folosită în numeroase probleme practice 19

20 Sisteme de calcul dedicate cu microcontroler care pot fi rezolvate utilizând modelul automatului finit. Acest automat finit este unul simplu: implementarea sa, utilizând modelul propus, cuprinde funcții simple pentru verificarea intrării și generarea acțiunilor corespunzătoare stărilor (i.e. ieșirile automatului). Acestea sunt funcții mai simple în comparație cu funcția principală FSM_Run a modelului propus. Acest fapt permite o mai bună estimare a complexității, măsurată în numărul ciclurilor necesare pentru execuția sa, a funcției FSM_Run, comparativ cu restul codului. O diagramă a sistemului detector de secvență este prezentată în Figura Figura Automat finit pentru detecția secvenței (0,0,1) Detectorul de secvență este proiectat să recunoască secvența valorilor binare {0, 0, 1}, prezentă la aplicată secvențial la intrarea sa. Dacă această secvență este prezentă la intrare, automatul generează valoarea 1 la ieșirea sa. În caz contrar ieșirea are valoarea 0. Graful de fluență pentru detectorul de secvență este prezentat în Figura Figura Graful de fluență al automatului finit pentru detecția secvenței (0,0,1) Pentru fiecare stare din graful de fluență este definită o tabelă a tranzițiilor ca în Figura Fiecare element al acestei tabele are două câmpuri: un pointer la o funcție care evaluează o condiție sau verifică un eveniment, și starea în care trece automatul finit, dacă condiția este adevărată sau dacă evenimentul s-a produs. // state transitions for each state static flash FSME_TRANS FSM1_S0_TRANS[] = { { FSM1_EventsUpdate0, FSM1_S1 } }; static flash FSME_TRANS FSM1_S1_TRANS[] = { { FSM1_EventsUpdate0, FSM1_S2 }, { FSM1_EventsUpdate1, FSM1_S0 } }; static flash FSME_TRANS FSM1_S2_TRANS[] = { { FSM1_EventsUpdate1, FSM1_S3 } }; static flash FSME_TRANS FSM1_S3_TRANS[] = { { FSM1_EventsUpdate0, FSM1_S1 }, { FSM1_EventsUpdate1, FSM1_S0 } }; Figura Structurile de date care descriu tranzițiile automatului finit utilizat în detectarea secvenței (0,0,1) În cazul automatului finit detector de secvență, funcțiile care verifică valoarea variabilei de intrare sunt prezentate în Figura static uint8 FSM1_EventsUpdate0( void ) { return ( in == 0 ); } static uint8 FSM1_EventsUpdate1( void ) { return ( in == 1 ); } Figura Funcțiile de verificare ale intrărilor automatului finit 20

21 Sisteme de calcul dedicate cu microcontroler Tabela stărilor pentru detectorul de secvență este ilustrată în Figura Fiecare stare este descrisă de propria funcție de acțiune, de numărul de tranziții către alte stări și de o tabelă care conține tranzițiile sub formă de perechi, alcătuite din funcția de verificare a condiției și codul pentru următoarea stare. // state outputs and transitions; entire table static flash FSME_STATE FSM1_STATES[] = { { FSM1_ActionClr, 1, FSM1_S0_TRANS}, { FSM1_ActionClr, 2, FSM1_S1_TRANS}, { FSM1_ActionClr, 1, FSM1_S2_TRANS}, { FSM1_ActionSet, 2, FSM1_S3_TRANS} }; Figura Structurile de date care descriu stările automatului finit care detectează secvența (0,0,1) Funcțiile de acțiune pentru detectorul de secvență sunt prezentate în Figura Fiecare funcție de ieșire are două căi de control. Una este pentru acțiuni care sunt executate o singură dată, la schimbarea stării. Cealaltă cale de control este pentru acțiuni care sunt executate în mod continuu, atât timp cât automatul finit rămâne în aceeași stare. static void FSM1_ActionClr( void ) { if ( FSM1.StateChanged == FSME_STATE_CHANGED ) { //actions to be executed only once in this state at the state change out = 0; // reset state changed flag FSM1.StateChanged = FSME_STATE_NOT_CHANGED; } else { /* actions to be executed continuously in this state */ } } static void FSM1_ActionSet( void ) { if ( FSM1.StateChanged == FSME_STATE_CHANGED ) { // actions to be executed only once in this state at the state change out = 1; // reset state changed flag FSM1.StateChanged = FSME_STATE_NOT_CHANGED; } else { /* actions to be executed continuously in this state */ } } Figura Funcțiile de activare (ale ieșirilor) ale automatului finit care detectează secvența (0,0,1) Instanța din automatul finit care implementează detectorul de secvență este prezentată în Figura Câmpurile automatului finit sunt inițializate astfel: automatul finit este activat (FSME_ENABLE), starea inițială este FSMI_S0, numărul de stări este setat la FSM1_STATES_NO, indicatorul destinat schimbării de stare este setat la FSME_STATE_CHANGE, cu scopul de a determina executarea funcției de acțiune pentru starea inițială și, în cele din urmă, tabelul stărilor este setat la FSM1_STATES. Ultimele două câmpuri rețin numărul de tranziții din starea inițială (1) și tabelul tranzițiilor pentru starea inițială. FSME_FSM FSM1 = { FSME_ENABLE, FSM1_S0, FSM1_STATES_NO, FSME_STATE_CHANGED, FSM1_STATES, 1, FSM1_S0_TRANS }; 21

22 Sisteme de calcul dedicate cu microcontroler Figura Structura de date care reprezintă automatul finit care detectează secvența (0,0,1) Pentru a evalua performanța implementării au fost proiectate și create multiple configurații ale aplicației. În acest fel, se poate evalua impactul unor factorilor care țin de mediul de dezvoltare supra performanței execuției aplicației. Aplicația care conține automatul finit este creată și compilată în patru configurații diferite: configurația 1: structurile de date care descriu automatul finit sunt memorate în SRAM și optimizările compilatorului sunt setate la nivel scăzut; configurația 2: structurile de date care descriu automatul finit sunt memorate în SRAM și optimizările compilatorului sunt setate la nivel ridicat; configurația 3: structurile de date care descriu automatul finit sunt memorate în FLASH și optimizările compilatorului sunt setate la nivel scăzut; configurația 4: structurile de date care descriu automatul finit sunt memorate în FLASH și optimizările compilatorului sunt setate la nivel ridicat. Cantitatea de memorie utilizată obținută după procesul de compilare al fiecărei configurații este prezentată în Figura Memoria SRAM a microcontrolerului, folosită în aplicațiile software este o resursă valoroasă. Mărimea sa este, în general, mai mică decât mărimea memoriei FLASH. În diverse modele se va alege stocarea informației automatului finit în memoria SRAM sau în memoria FLASH, în funcție de nevoile specifice ale aplicației. Impactul acestei decizii de utilizare a memoriei asupra detectorului de secvență este prezentată în Figura Figura Resursele de memorie utilizate de implementarea automatului finit (Stan, Botezatu, Panduru, & Lupu, 2009) Pentru a putea evalua timpul de execuție al modelului de automat finit s-a dezvoltat un script pentru simulatorul IAR. Script-ul numără ciclurile scurse între două apeluri succesive ale funcției FSM_Run (&FSM1). Secvența de intrare utilizată în procesul de simulare are valori care activează toate tranzițiile posibile ale acestui automat finit. Media numărului de cicluri obținută după procesul de simulare pentru fiecare configurație este prezentată în Figura Numărul de ciclurilor este ușor mai mare în cazul configurațiilor care au stocat informația automatului finit în memoria FLASH. Acest lucru se întâmplă deoarece este nevoie de un număr mai mare de cicluri pentru a citi datele din memoria FLASH, în comparație cu numărul de cicluri necesare pentru a citi datele reținute în memoria SRAM. 22

23 Sisteme de calcul dedicate cu microcontroler Figura Timpul de execuție a implementării automatului finit (Stan, Botezatu, Panduru, & Lupu, 2009) Script-ul de simulare evaluează și numărul de cicluri necesare fiecărei tranziții realizate în decursul procesului de simulare. Numărul de cicluri pentru fiecare tranziție din configurația 2 este prezentat în Tabelul și pentru cei din configurația 4 este prezentat în Tabelul Tabelul Numărul de cicluri pentru tranzițiile automatului finit în configurația 2 (Stan, Botezatu, Panduru, & Lupu, 2009) Stare curentă / Stare următoare S0 S1 S2 S3 S S S S Tabelul Numărul de cicluri pentru tranzițiile automatului finit în configurația 4 (Stan, Botezatu, Panduru, & Lupu, 2009) Stare curentă / Stare următoare S0 S1 S2 S3 S S S S Această particularitate poate fi utilizată în validarea tabelei de tranziții pentru un automat finit. În tabelele anterioare, valoarea zero semnifică absența execuției tranziției respective, iar o valoare diferită de zero denotă că tranziția respectivă s-a realizat în timpul procesului de simulare și durata sa este egală cu numărul de cicluri notat în tabel. Valorile timpilor de execuție pot fi folosite ca o informație despre execuția corectă a automatului finit. Valorile acestea pot fi utilizate ulterior la implementarea unor mecanisme de verificare a corectitudinii execuției automatului finit Automat finit cu mecanism de siguranță Implementare Se continuă dezvoltarea modelului anterior prin modificarea modelului de automat finit cu implementarea unui mecanism de siguranţă (Stan, Botezatu, & Vieriu, 2009). Operarea sigură este un aspect esenţial în sistemele de calcul dedicate complexe. Pentru a atinge un nivel ridicat de siguranţă, o metodă este validarea temporală a valorilor intrărilor în automatul finit şi a ieșirilor 23

24 Sisteme de calcul dedicate cu microcontroler generate de automat. Implementarea propusă include o verificare a timpului pe care un automat îl petrece în fiecare stare, ceea ce previne ca automatul finit să aştepte la nesfârşit o condiţie pentru a realiza o schimbare de stare şi să menţină ieşirile active mai mult decât este necesar sau decât este sigur. Implementarea trebuie să fie eficientă din punctul de vedere al încărcării memoriei şi al timpului de execuţie. Modelul de nucleu propus pentru un automat finit cu mecanism de siguranță este definit de stările, evenimentele sau condiţiile care declanşează tranziţia dintre stări, de funcţiile care activează sau dezactivează ieșirile şi de valorile timpului maxim de staționare în fiecare stare. Fiecare stare este descrisă de tipul de date FSME_STATE, prezentat în Figura , care conţine informaţii despre funcţia de activare, tranziţiile din această stare şi o valoare de temporizare care limitează intervalul de timp pentru care automatul finit poate rămâne în starea curentă. Informaţiile pentru funcţia de activare sunt reprezentate de un pointer la funcţie asociat unei stări, având în vedere faptul că modelul de automat finit este pentru automate de tip Moore. // function pointer type for action (output) functions typedef void (*FSME_PF) (void); // function pointer type for transition checking typedef uint8 (*FSME_PF) (void); // state type - describes a FSM state using the following fields: // Action a pointer to an action (output) function // Event a pointer to function that checks the conditions that may trigger a transition from the current state; // TimeOut the maximum ammount of time that the FSM is allowed to stay in the current state typedef struct { FSME_PF Action; FSME_PF_EV Event; uint16 TimeOut; } FSME_STATE; Figura Structura de date care descrie starea unui automat finit cu mecanism de siguranță (Stan, Botezatu, & Vieriu, 2009) Tranziţiile din starea curentă sunt determinate de câmpul Event al structurii FSME_STATE. Acest membru este un pointer la o funcţie care verifică toate evenimentele şi condiţiile care pot declanşa o tranziţie din starea curentă. Dacă se declanşează o tranziţie prin apariţia unui eveniment sau a unei condiţii adevărate, funcţia Event schimbă codul stării curente cu codul pentru următoarea stare în care va ajunge automatul finit. Tipul de structură pentru modelul de automat finit este FSME_FSM prezentată în Figura Structura constă dintr-un indicator care semnalează o schimbare în starea automatului finit şi din câmpuri care descriu: starea curentă, starea de siguranţă în care ajunge automatul finit în cazul expirării timpului de staționare într-o stare, o referință la o tabelă care conţine stările automatului finit şi un index pentru un timer folosit pentru contorizarea timpului petrecut în starea curentă. // FSM type - describes a FSM using the following fields: typedef struct { uint8 Enable; uint8 StateChanged; uint8 CurrentState; uint8 SafeState; FSME_STATE * States; uint8 TimerIdx; } FSME_FSM; Figura Structura de date care descrie un automat finit cu mecanism de siguranță (Stan, Botezatu, & Vieriu, 2009) 24

25 Sisteme de calcul dedicate cu microcontroler start (FSME_Run) /*fixare variabilă cu noua stare a automatului finit*/ _n = F->States[F->CurrentState].Event(); TRUE /*verificare schimbare de stare*/ _n!= FSME_NO_STATE_CHANGE FALSE /*actualizare stare curentă*/ F->CurrentState = _n FALSE /*verificare contor de timp pentru starea curentă*/ TRUE == timer_checktimer10ms( F->TimerIdx ) /*actualizare indicator schimbare stareg*/ F->StateChanged = FSME_STATE_CHANGED TRUE /*actualizare stare curentă*/ F->CurrentState = F->SafeState /*repornire a contorului de timp*/ timer_restarttimer10ms( F->TimerIdx, F->States[ F->CurrentState ].TimeOut ); /*actualizare indicator schimbare stare*/ F->StateChanged = FSME_STATE_CHANGED /*repornire a contorului de timp*/ timer_restarttimer10ms( F->TimerIdx, F->States[ F->CurrentState ].TimeOut ); /*Apelare funcție de acționare (ieșire) corespunzătoare stării curente*/ F->States[ F->CurrentState ].Action() stop (FSME_Run) Figura Funcția de execuție pentru un automat finit cu mecanism de siguranță Orice apelare a funcţiei FSME_Run, prezentată în Figura , verifică mai întâi dacă automatul finit este activat sau nu. Dacă este activat, funcţia FSME_Run verifică apoi dacă starea s-a schimbat prin apelarea funcţiei Event pentru starea curentă. Dacă starea automatului finit s-a schimbat, starea curentă este actualizată în consecinţă şi contorul (engl. timer) pentru măsurarea timpului petrecut în starea curentă este resetat la valoarea corespunzătoare noii stări. Dacă starea automatului finit rămâne neschimbată, funcţia FSME_Run verifică dacă valoarea de contorului pentru starea curentă indică o depășire. În acest caz automatul finit intră într-o stare de siguranţă. În această stare se poate iniţia un ciclu de oprire în siguranță a sistemului dedicat. La sfârşitul funcţiei FSME_Run este apelată funcţia Action pentru starea curentă Evaluarea modelului propus Pentru a evalua modelul de automat finit propus s-a creat un mediu special pentru acest scop. Mediul de evaluare este pentru microcontrolere pe 8 biţi: familia de controlere ATMega de la Atmel. 25

26 Sisteme de calcul dedicate cu microcontroler Mediul de evaluare foloseşte următoarele componente: un modul de automat finit construit cu modelul propus, un compilator C pentru microcontrolerele ATMega (IAR Systems, IAR Embedded Workbench for Atmel AVR, 2011), şi simulatorul integrat în IAR IDE. Un detector de secvenţă (pentru secvența 0,0,1), prezentat în Figura , este implementat folosind modelul de automat finit propus. Revenirea în ciclul normal de funcționare din starea S4 de eroare (în care se ajunge după depășirea timpului maxim de staționare într-una din stările S0,, S3) se poate face după scurgerea unui interval de timp, sau după intervenția explicită a operatorului sistemului controlat de acest automat. Figura Graful de fluență al automatului finit cu mecanism de siguranță pentru detecția secvenței (0,0,1) Scenariul de simulare calculează de asemenea numărul de cicluri necesare pentru fiecare tranziţie care a apărut în timpul operării procesului de simulare. Numărul de cicluri pentru fiecare tranziţie a automatului finit este prezentat în Tabelul Acest tabel poate fi folosit de asemenea pentru a verifica corectitudinea implementării. Modulul implementat ocupă doar 156 octeți din memoria de cod. Pentru implementarea detectorului de secvenţă memoria folosită este de 147 octeți memoria de cod (plus 156 octeți pentru bibliotecă) şi 7 octeți de memorie date. Tabelul Numărul de cicluri pentru tranzițiile automatului finit cu mecanism de siguranță (Stan, Botezatu, & Vieriu, 2009) Stare curentă / Stare următoare S0 S1 S2 S3 S4 S S S S S

27 Sisteme de calcul dedicate cu microcontroler 3.2 Bibliotecă de funcții pentru criptare Securitatea este necesară pentru un număr tot mai mare de sisteme dedicate. Progresul tehnologic care a dat naştere acestor sisteme electronice a impus şi o tendinţă de creştere a complexităţii atacurilor pentru subminarea securităţii. Numărul tot mai mare de încercări de exploatare a lacunelor din sistemele de asigurare a securității informaţiilor, a motivat creşterea efortului de securizare a sistemelor electronice. Sistemele dedicate folosite la achiziţia, stocarea, manipularea şi procesarea datelor de o natură sensibilă, ridică câteva provocări unice şi interesante din punct de vedere al securităţii. Securitatea a făcut subiectul cercetării în domenii precum criptografia şi ştiinţa calculatoarelor şi a reţelelor de calculatoare. Cu toate acestea, securitatea este de obicei omisă sau interpretată ca o funcţie anexă în procesul de proiectare al sistemelor dedicate. În realitate, securitatea ar trebui sa reprezinte o nouă metrică în procesul de proiectare alături de cost, performanţe şi puterea consumată. Pentru aceste sisteme există câţiva factori care translează considerentele de securitate dintr-o perspectivă central-funcţională spre o problemă de proiectare arhitecturală (hardware și software): Un sistem dedicat trebuie să fie sigur chiar şi când poate fi accesat fizic sau logic de entităţi neautorizate. Rezistenţa la astfel de atacuri poate fi asigurată doar dacă sistemul a fost proiectat pentru asemenea cazuri. Posibilităţile de procesare ale multor sisteme dedicate sunt uşor depăşite de nevoile computaţionale ale modulelor de securitate, acest lucru ducând la compromisuri indezirabile între securitate şi cost sau securitate şi performanţă. Sistemele alimentate de la baterie (şi dispozitivele cu constrângeri de dimensiuni) în general operează cu resurse limitate, precum capacitatea bateriei, spaţiul de stocare, capacitatea de procesare, acestea fiind suprasolicitate de cerinţele impuse prin securitate. Sistemele dedicate trebuie să fie suficient de flexibile pentru a se adapta evoluţiei rapide a mecanismelor de securitate. Proiectarea sistemelor care iau în considerare eficienţa energetică reprezintă o provocare pentru arhitecturile de sisteme de calcul dedicate (De Bosschere, et al., 2007) Metode de criptare Pentru modelul de securizare propus există două tipuri de metode pentru securizarea informațiilor transferate: metoda de generare a cheii de sesiune; metoda de transfer de date. Figura prezintă generarea cheii de sesiune şi metoda de schimb. O sesiune este iniţiată atunci când sistemului i se adaugă un nou nod. De asemenea, atunci când nodul adăugat schimbă dinamic metoda de criptare folosită, pe baza cerinţelor de energie, este necesară o nouă cheie de criptare, care necesită în consecinţă o nouă sesiune de generare a cheii de criptare. Schimbarea frecventă a cheii de criptare pentru sesiunile de comunicație poate să crească rezistența la atacuri a comunicațiilor de date dintre sisteme. 27

28 Sisteme de calcul dedicate cu microcontroler System administrator Initial known Key K K Initial known Key K C 1 E K (K 1 )=C 1 D K (C 1 )=K 1 K 1 K K 1 E K1 (C 2 )=C 3 C 3 D K1 (C 3 )=C 2 C 2 C 2 E K (K 2 )=C 2 D K (C 2 )= K 2 K 2 Key generation Session key: K 2 Node A (Master) Node B (Slave) Figura Metoda de generare a cheii de criptare pentru o sesiune de comunicație (Stan & Botezatu, 2009) Nodurile sistemului au o cheie iniţială (K). Această cheie este setată o dată la prima utilizare a sistemului şi poate fi resetată în mod regulat de către administratorul de sistem. Atunci când este iniţiată o nouă sesiune, nodul master (Nodul A) creează două chei: K1 şi K2. Aceste chei pot fi numere aleatorii pe 64 de biţi calculate folosind un algoritm de generare și o sămânță dedusă dintr-o expresie care include valori provenite de la o intrare neconectată a unui modul ADC, temperatura mediului ambiant şi ceasul de timp real. Prima etapă a metodei de schimb constă în criptarea valorii lui K1 cu cheia inițială K; datele codificate obţinute (C1) vor fi transmise nodului B printr-un canal de comunicație nesecurizat. În a doua etapă, K2 este criptat cu cheia K şi datele codificate rezultate (C2) sunt codificate cu cheia K1 generată anterior. Datele rezultate (C3) sunt, de asemenea, transmise receptorului prin intermediul unei conexiuni nesecurizate. Ultimele două etape ale procesului se desfăşoară pe nodul B. După ce are loc recepţionarea datelor C1, se iniţiază etapa a treia. Această etapă constă în decriptarea lui C1 cu ajutorul cheii K, rezultând cheia K1. Apoi, în ultima etapă, datele C3 recepţionate sunt decriptate folosindu-se cheia K1; datele rezultate, C2, sunt decodificate cu cheia K pentru a obţine cheia K2. Toate datele transmise ulterior în cadrul sesiunii sunt criptate şi decriptate cu cheia de sesiune K2. Session key: K Session key: K 2 2 K 2 K 2 Cd 1 E K (d)=cd 1 K 2 D K2 (Cd 1 )=d 1 K 2 d 1 D K2 (Cd 2 )=d 2 Cd 2 E K2 (d 2 )=Cd 2 d 2 Data Data Node A (Master) Node B (Slave) Figura Metoda pentru schimbul de date (Stan & Botezatu, 2009) 28

29 Sisteme de calcul dedicate cu microcontroler Metoda schimbului de date este prezentată în Figura Cele două noduri de comunicație au aceeaşi cheie de sesiune, K2, generată conform pașilor descriși anterior. Procesele de criptare și decriptare au la bază această cheie, deoarece datele care traversează canalul nesecurizat sunt codificate la sursă şi decodificate la sistemul destinaţie prin folosirea cheii K Algoritmi de criptare Algoritmii de criptare reprezintă fundamentul metodelor de criptare. Metodele de criptare propuse folosesc algoritmii de criptare pentru managementul datelor sensibile. Codificarea datelor este procesul care transformă reprezentarea din text simplu a valorilor într-o reprezentare prin text codificat, utilizând un algoritm de criptare selectat şi o cheie secretă folosită de algoritm. Managementul datelor sensibile se referă îndeosebi la procesul de management al cheii, incluzând: generarea cheii, protocolul de schimbare a cheii şi algoritmul de codificare folosit pentru criptarea cheii. În scopurile menţionate, au fost selectați şi implementați doi algoritmi de criptare: FEAL (Fast Data Encipherment Algorithm Algoritm de Criptare Rapidă a Datelor) şi DES (Data Encryption Standard Standard de Criptare a Datelor). Ambii algoritmi sunt algoritmi de criptare simetrici cu cheie privată care operează pe blocuri de date Pentru multe aplicații, acest tip de algoritmi de criptare corespund necesităţilor de comunicație a sistemelor dedicate datorită structurii orientate pe blocuri a datelor comunicate. De asemenea, lungimea blocului pentru algoritmii de criptare este un bun echivalent al (sau un mic număr de multipli ai) volumului de date comunicate Evaluarea implementării algoritmilor de criptare Implementarea algoritmilor de criptare se desfăşoară potrivit următoarelor reguli pentru minimizarea consumului de resurse: se evită lucrul cu şiruri de octeți, folosindu-se în schimb tipuri de date întregi suportate de arhitectură (e.g. întregi pe 32 de biţi) şi de compilator (e.g. întregi pe 64 de biţi); se evită utilizarea multor funcţii: se evită transmiterea parametrilor şi secvenţele frecvente de apel și revenire din funcție. Pentru implementarea şi evaluarea algoritmilor de criptare, s-a folosit o platformă de dezvoltare cu un microcontroler ARM Coretx-M3 STM32F103RB (ST Microelectronics, 2011) şi compilatorul CrossWorks pentru ARM (Rowley Associates, 2011). Numărul de cicluri pentru execuția algoritmilor de criptare este prezentat în Tabelul şi în Tabelul Valorile pentru numărul de cicluri sunt calculate pentru diferite lungimi ale datelor criptate şi pentru numere diferite de runde pe care algoritmul le execută pentru criptarea datelor. După cum s-a specificat anterior, algoritmii de decriptare şi cei de criptare sunt identici, cu deosebirea că subcheile sunt aplicate etapelor interne în ordine inversă. Acest aspect face ca algoritmii de decriptare să aibă acelaşi număr de cicluri pentru operațiile de criptare și decriptare. Tabelul Numărul de cicluri pentru execuția algoritmului de criptare DES (Stan & Botezatu, 2009) Lungimea blocului Numărul de runde de criptare de date 64 bit bit bit Tabelul Numărul de cicluri pentru execuția algoritmului de criptare FEAL (Stan & Botezatu, 2009) Lungimea blocului Numărul de runde de criptare de date 64 bit bit bit

30 Sisteme de calcul dedicate cu microcontroler Calcularea numărului ciclurilor permite măsurarea directă a timpului de execuţie. Aceste tabele conţin informaţii pe care o aplicaţie le poate utiliza pentru a estima timpul de execuţie necesar pentru un algoritm de criptare şi, prin urmare, energia necesară pentru execuţia algoritmului respectiv. Prin utilizarea informaţiilor din tabelele anterioare, o aplicaţie poate selecta dinamic algoritmul pe care să-l lanseze în execuţie pentru a cripta sau decripta date. Selecţia se face în baza bugetului de energie al sistemului, astfel încât să se asigure o perioadă de funcţionare cât mai îndelungată. Tabelele prezentate anterior conţin informaţii care stau la baza implementării sistemelor care monitorizează consumul de energie pe durata perioadei de execuție. Au fost măsurați, de asemenea, timpii de execuţie pentru diferite versiuni de algoritmi de criptare DES şi FEAL (i.e. diferite lungimi ale blocului de date procesat) în condițiile utilizării unei frecvenţe a ceasului de 72MHz pentru microcontroler. Pentru măsurarea acestor valori s-a utilizat un timer intern al microcontrolerului. Valorile timpului de execuţie sunt calculate pentru diferite lungimi de date criptate şi pentru diferite numere de runde pe care algoritmul le execută în vederea codificării datelor. Valorile măsurate sunt prezentate în Figura şi Figura Figura Timpul de execuție pentru criptarea unui bloc da date cu algoritmul DES (Stan & Botezatu, 2009) Figura Timpul de execuție pentru criptarea unui bloc de date cu algoritmul FEAL (Stan & Botezatu, 2009) În continuare este prezentat un scenariu tipic de consum de energie bazat pe metodele descrise. Acesta implică folosirea algoritmului DES16 în procesul de criptare sau decriptare a cheii de sesiune şi transmiterea unei secvenţe de date pe 16 biţi criptate cu FEAL8. Cele trei etape de decriptare necesare la începutul sesiunii solicită de cicluri pentru a fi executate. Următoarele date pe 128 de biţi necesită 3696 de cicluri pentru realizarea criptării. La un consum, în starea normală de funcționare (i.e. nu în moduri de consum redus de energie), de 38,1 3,3V 30